We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dfs#1(nil(), @x) -> leaf()
, dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, dodfs(@t, @x) -> dfs(::(@t, nil()), @x)
, bfs2#1(@t', @x) -> dobfs(@t', @x)
, bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x)
, dfs#2(node(@a, @t1, @t2), @t, @ts, @x) ->
dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
, dfs(@queue, @x) -> dfs#1(@queue, @x)
, dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t
, dfs#3(#false(), @t, @t1, @t2, @ts, @x) ->
dfs(::(@t1, ::(@t2, @ts)), @x) }
Weak Trs:
{ #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We add the following dependency tuples:
Strict DPs:
{ #equal^#(@x, @y) -> c_1(#eq^#(@x, @y))
, bfs#4^#(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_2()
, bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_3(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, bfs^#(@queue, @futurequeue, @x) ->
c_14(bfs#1^#(@queue, @futurequeue, @x))
, reverse^#(@xs) -> c_4(appendreverse^#(@xs, nil()))
, appendreverse^#(@toreverse, @sofar) ->
c_7(appendreverse#1^#(@toreverse, @sofar))
, appendreverse#1^#(nil(), @sofar) -> c_5()
, appendreverse#1^#(::(@a, @as), @sofar) ->
c_6(appendreverse^#(@as, ::(@a, @sofar)))
, dfs#1^#(nil(), @x) -> c_8()
, dfs#1^#(::(@t, @ts), @x) -> c_9(dfs#2^#(@t, @t, @ts, @x))
, dfs#2^#(leaf(), @t, @ts, @x) -> c_19(dfs^#(@ts, @x))
, dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_20(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x),
#equal^#(@a, @x))
, dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x))
, dodfs^#(@t, @x) -> c_11(dfs^#(::(@t, nil()), @x))
, dfs^#(@queue, @x) -> c_23(dfs#1^#(@queue, @x))
, bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, bfs#1^#(nil(), @futurequeue, @x) ->
c_17(bfs#2^#(@futurequeue, @x))
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_18(bfs#3^#(@t, @futurequeue, @ts, @x))
, bfs#2^#(nil(), @x) -> c_15()
, bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_21(bfs^#(@ts, @futurequeue, @x))
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_22(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y),
#equal^#(@x, @y))
, dfs#3^#(#true(), @t, @t1, @t2, @ts, @x) -> c_24()
, dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_25(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
Weak DPs:
{ #eq^#(leaf(), leaf()) -> c_26()
, #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_27()
, #eq^#(leaf(), nil()) -> c_28()
, #eq^#(leaf(), ::(@y_1, @y_2)) -> c_29()
, #eq^#(#pos(@x), #pos(@y)) -> c_30(#eq^#(@x, @y))
, #eq^#(#pos(@x), #0()) -> c_31()
, #eq^#(#pos(@x), #neg(@y)) -> c_32()
, #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_33()
, #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
c_34(#and^#(#eq(@x_1, @y_1),
#and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))),
#eq^#(@x_1, @y_1),
#and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)),
#eq^#(@x_2, @y_2),
#eq^#(@x_3, @y_3))
, #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_35()
, #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_36()
, #eq^#(nil(), leaf()) -> c_37()
, #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_38()
, #eq^#(nil(), nil()) -> c_39()
, #eq^#(nil(), ::(@y_1, @y_2)) -> c_40()
, #eq^#(::(@x_1, @x_2), leaf()) -> c_41()
, #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_42()
, #eq^#(::(@x_1, @x_2), nil()) -> c_43()
, #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_44(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, #eq^#(#0(), #pos(@y)) -> c_45()
, #eq^#(#0(), #0()) -> c_46()
, #eq^#(#0(), #neg(@y)) -> c_47()
, #eq^#(#0(), #s(@y)) -> c_48()
, #eq^#(#neg(@x), #pos(@y)) -> c_49()
, #eq^#(#neg(@x), #0()) -> c_50()
, #eq^#(#neg(@x), #neg(@y)) -> c_51(#eq^#(@x, @y))
, #eq^#(#s(@x), #0()) -> c_52()
, #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y))
, #and^#(#true(), #true()) -> c_54()
, #and^#(#true(), #false()) -> c_55()
, #and^#(#false(), #true()) -> c_56()
, #and^#(#false(), #false()) -> c_57() }
and mark the set of starting terms.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ #equal^#(@x, @y) -> c_1(#eq^#(@x, @y))
, bfs#4^#(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_2()
, bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_3(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, bfs^#(@queue, @futurequeue, @x) ->
c_14(bfs#1^#(@queue, @futurequeue, @x))
, reverse^#(@xs) -> c_4(appendreverse^#(@xs, nil()))
, appendreverse^#(@toreverse, @sofar) ->
c_7(appendreverse#1^#(@toreverse, @sofar))
, appendreverse#1^#(nil(), @sofar) -> c_5()
, appendreverse#1^#(::(@a, @as), @sofar) ->
c_6(appendreverse^#(@as, ::(@a, @sofar)))
, dfs#1^#(nil(), @x) -> c_8()
, dfs#1^#(::(@t, @ts), @x) -> c_9(dfs#2^#(@t, @t, @ts, @x))
, dfs#2^#(leaf(), @t, @ts, @x) -> c_19(dfs^#(@ts, @x))
, dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_20(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x),
#equal^#(@a, @x))
, dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x))
, dodfs^#(@t, @x) -> c_11(dfs^#(::(@t, nil()), @x))
, dfs^#(@queue, @x) -> c_23(dfs#1^#(@queue, @x))
, bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, bfs#1^#(nil(), @futurequeue, @x) ->
c_17(bfs#2^#(@futurequeue, @x))
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_18(bfs#3^#(@t, @futurequeue, @ts, @x))
, bfs#2^#(nil(), @x) -> c_15()
, bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_21(bfs^#(@ts, @futurequeue, @x))
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_22(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y),
#equal^#(@x, @y))
, dfs#3^#(#true(), @t, @t1, @t2, @ts, @x) -> c_24()
, dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_25(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
Weak DPs:
{ #eq^#(leaf(), leaf()) -> c_26()
, #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_27()
, #eq^#(leaf(), nil()) -> c_28()
, #eq^#(leaf(), ::(@y_1, @y_2)) -> c_29()
, #eq^#(#pos(@x), #pos(@y)) -> c_30(#eq^#(@x, @y))
, #eq^#(#pos(@x), #0()) -> c_31()
, #eq^#(#pos(@x), #neg(@y)) -> c_32()
, #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_33()
, #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
c_34(#and^#(#eq(@x_1, @y_1),
#and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))),
#eq^#(@x_1, @y_1),
#and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)),
#eq^#(@x_2, @y_2),
#eq^#(@x_3, @y_3))
, #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_35()
, #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_36()
, #eq^#(nil(), leaf()) -> c_37()
, #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_38()
, #eq^#(nil(), nil()) -> c_39()
, #eq^#(nil(), ::(@y_1, @y_2)) -> c_40()
, #eq^#(::(@x_1, @x_2), leaf()) -> c_41()
, #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_42()
, #eq^#(::(@x_1, @x_2), nil()) -> c_43()
, #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_44(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, #eq^#(#0(), #pos(@y)) -> c_45()
, #eq^#(#0(), #0()) -> c_46()
, #eq^#(#0(), #neg(@y)) -> c_47()
, #eq^#(#0(), #s(@y)) -> c_48()
, #eq^#(#neg(@x), #pos(@y)) -> c_49()
, #eq^#(#neg(@x), #0()) -> c_50()
, #eq^#(#neg(@x), #neg(@y)) -> c_51(#eq^#(@x, @y))
, #eq^#(#s(@x), #0()) -> c_52()
, #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y))
, #and^#(#true(), #true()) -> c_54()
, #and^#(#true(), #false()) -> c_55()
, #and^#(#false(), #true()) -> c_56()
, #and^#(#false(), #false()) -> c_57() }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dfs#1(nil(), @x) -> leaf()
, dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, dodfs(@t, @x) -> dfs(::(@t, nil()), @x)
, bfs2#1(@t', @x) -> dobfs(@t', @x)
, bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x)
, dfs#2(node(@a, @t1, @t2), @t, @ts, @x) ->
dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
, dfs(@queue, @x) -> dfs#1(@queue, @x)
, dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t
, dfs#3(#false(), @t, @t1, @t2, @ts, @x) ->
dfs(::(@t1, ::(@t2, @ts)), @x) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We estimate the number of application of {1,2,7,9,20,24} by
applications of Pre({1,2,7,9,20,24}) = {6,12,15,18,23}. Here rules
are labeled as follows:
DPs:
{ 1: #equal^#(@x, @y) -> c_1(#eq^#(@x, @y))
, 2: bfs#4^#(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_2()
, 3: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_3(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, 4: bfs^#(@queue, @futurequeue, @x) ->
c_14(bfs#1^#(@queue, @futurequeue, @x))
, 5: reverse^#(@xs) -> c_4(appendreverse^#(@xs, nil()))
, 6: appendreverse^#(@toreverse, @sofar) ->
c_7(appendreverse#1^#(@toreverse, @sofar))
, 7: appendreverse#1^#(nil(), @sofar) -> c_5()
, 8: appendreverse#1^#(::(@a, @as), @sofar) ->
c_6(appendreverse^#(@as, ::(@a, @sofar)))
, 9: dfs#1^#(nil(), @x) -> c_8()
, 10: dfs#1^#(::(@t, @ts), @x) -> c_9(dfs#2^#(@t, @t, @ts, @x))
, 11: dfs#2^#(leaf(), @t, @ts, @x) -> c_19(dfs^#(@ts, @x))
, 12: dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_20(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x),
#equal^#(@a, @x))
, 13: dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x))
, 14: dodfs^#(@t, @x) -> c_11(dfs^#(::(@t, nil()), @x))
, 15: dfs^#(@queue, @x) -> c_23(dfs#1^#(@queue, @x))
, 16: bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, 17: bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, 18: bfs#1^#(nil(), @futurequeue, @x) ->
c_17(bfs#2^#(@futurequeue, @x))
, 19: bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_18(bfs#3^#(@t, @futurequeue, @ts, @x))
, 20: bfs#2^#(nil(), @x) -> c_15()
, 21: bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, 22: bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_21(bfs^#(@ts, @futurequeue, @x))
, 23: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_22(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y),
#equal^#(@x, @y))
, 24: dfs#3^#(#true(), @t, @t1, @t2, @ts, @x) -> c_24()
, 25: dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_25(dfs^#(::(@t1, ::(@t2, @ts)), @x))
, 26: #eq^#(leaf(), leaf()) -> c_26()
, 27: #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_27()
, 28: #eq^#(leaf(), nil()) -> c_28()
, 29: #eq^#(leaf(), ::(@y_1, @y_2)) -> c_29()
, 30: #eq^#(#pos(@x), #pos(@y)) -> c_30(#eq^#(@x, @y))
, 31: #eq^#(#pos(@x), #0()) -> c_31()
, 32: #eq^#(#pos(@x), #neg(@y)) -> c_32()
, 33: #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_33()
, 34: #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
c_34(#and^#(#eq(@x_1, @y_1),
#and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))),
#eq^#(@x_1, @y_1),
#and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)),
#eq^#(@x_2, @y_2),
#eq^#(@x_3, @y_3))
, 35: #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_35()
, 36: #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_36()
, 37: #eq^#(nil(), leaf()) -> c_37()
, 38: #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_38()
, 39: #eq^#(nil(), nil()) -> c_39()
, 40: #eq^#(nil(), ::(@y_1, @y_2)) -> c_40()
, 41: #eq^#(::(@x_1, @x_2), leaf()) -> c_41()
, 42: #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_42()
, 43: #eq^#(::(@x_1, @x_2), nil()) -> c_43()
, 44: #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_44(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, 45: #eq^#(#0(), #pos(@y)) -> c_45()
, 46: #eq^#(#0(), #0()) -> c_46()
, 47: #eq^#(#0(), #neg(@y)) -> c_47()
, 48: #eq^#(#0(), #s(@y)) -> c_48()
, 49: #eq^#(#neg(@x), #pos(@y)) -> c_49()
, 50: #eq^#(#neg(@x), #0()) -> c_50()
, 51: #eq^#(#neg(@x), #neg(@y)) -> c_51(#eq^#(@x, @y))
, 52: #eq^#(#s(@x), #0()) -> c_52()
, 53: #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y))
, 54: #and^#(#true(), #true()) -> c_54()
, 55: #and^#(#true(), #false()) -> c_55()
, 56: #and^#(#false(), #true()) -> c_56()
, 57: #and^#(#false(), #false()) -> c_57() }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_3(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, bfs^#(@queue, @futurequeue, @x) ->
c_14(bfs#1^#(@queue, @futurequeue, @x))
, reverse^#(@xs) -> c_4(appendreverse^#(@xs, nil()))
, appendreverse^#(@toreverse, @sofar) ->
c_7(appendreverse#1^#(@toreverse, @sofar))
, appendreverse#1^#(::(@a, @as), @sofar) ->
c_6(appendreverse^#(@as, ::(@a, @sofar)))
, dfs#1^#(::(@t, @ts), @x) -> c_9(dfs#2^#(@t, @t, @ts, @x))
, dfs#2^#(leaf(), @t, @ts, @x) -> c_19(dfs^#(@ts, @x))
, dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_20(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x),
#equal^#(@a, @x))
, dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x))
, dodfs^#(@t, @x) -> c_11(dfs^#(::(@t, nil()), @x))
, dfs^#(@queue, @x) -> c_23(dfs#1^#(@queue, @x))
, bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, bfs#1^#(nil(), @futurequeue, @x) ->
c_17(bfs#2^#(@futurequeue, @x))
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_18(bfs#3^#(@t, @futurequeue, @ts, @x))
, bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_21(bfs^#(@ts, @futurequeue, @x))
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_22(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y),
#equal^#(@x, @y))
, dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_25(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
Weak DPs:
{ #equal^#(@x, @y) -> c_1(#eq^#(@x, @y))
, #eq^#(leaf(), leaf()) -> c_26()
, #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_27()
, #eq^#(leaf(), nil()) -> c_28()
, #eq^#(leaf(), ::(@y_1, @y_2)) -> c_29()
, #eq^#(#pos(@x), #pos(@y)) -> c_30(#eq^#(@x, @y))
, #eq^#(#pos(@x), #0()) -> c_31()
, #eq^#(#pos(@x), #neg(@y)) -> c_32()
, #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_33()
, #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
c_34(#and^#(#eq(@x_1, @y_1),
#and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))),
#eq^#(@x_1, @y_1),
#and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)),
#eq^#(@x_2, @y_2),
#eq^#(@x_3, @y_3))
, #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_35()
, #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_36()
, #eq^#(nil(), leaf()) -> c_37()
, #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_38()
, #eq^#(nil(), nil()) -> c_39()
, #eq^#(nil(), ::(@y_1, @y_2)) -> c_40()
, #eq^#(::(@x_1, @x_2), leaf()) -> c_41()
, #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_42()
, #eq^#(::(@x_1, @x_2), nil()) -> c_43()
, #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_44(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, #eq^#(#0(), #pos(@y)) -> c_45()
, #eq^#(#0(), #0()) -> c_46()
, #eq^#(#0(), #neg(@y)) -> c_47()
, #eq^#(#0(), #s(@y)) -> c_48()
, #eq^#(#neg(@x), #pos(@y)) -> c_49()
, #eq^#(#neg(@x), #0()) -> c_50()
, #eq^#(#neg(@x), #neg(@y)) -> c_51(#eq^#(@x, @y))
, #eq^#(#s(@x), #0()) -> c_52()
, #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y))
, bfs#4^#(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_2()
, appendreverse#1^#(nil(), @sofar) -> c_5()
, dfs#1^#(nil(), @x) -> c_8()
, bfs#2^#(nil(), @x) -> c_15()
, dfs#3^#(#true(), @t, @t1, @t2, @ts, @x) -> c_24()
, #and^#(#true(), #true()) -> c_54()
, #and^#(#true(), #false()) -> c_55()
, #and^#(#false(), #true()) -> c_56()
, #and^#(#false(), #false()) -> c_57() }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dfs#1(nil(), @x) -> leaf()
, dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, dodfs(@t, @x) -> dfs(::(@t, nil()), @x)
, bfs2#1(@t', @x) -> dobfs(@t', @x)
, bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x)
, dfs#2(node(@a, @t1, @t2), @t, @ts, @x) ->
dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
, dfs(@queue, @x) -> dfs#1(@queue, @x)
, dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t
, dfs#3(#false(), @t, @t1, @t2, @ts, @x) ->
dfs(::(@t1, ::(@t2, @ts)), @x) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
The following weak DPs constitute a sub-graph of the DG that is
closed under successors. The DPs are removed.
{ #equal^#(@x, @y) -> c_1(#eq^#(@x, @y))
, #eq^#(leaf(), leaf()) -> c_26()
, #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_27()
, #eq^#(leaf(), nil()) -> c_28()
, #eq^#(leaf(), ::(@y_1, @y_2)) -> c_29()
, #eq^#(#pos(@x), #pos(@y)) -> c_30(#eq^#(@x, @y))
, #eq^#(#pos(@x), #0()) -> c_31()
, #eq^#(#pos(@x), #neg(@y)) -> c_32()
, #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_33()
, #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
c_34(#and^#(#eq(@x_1, @y_1),
#and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))),
#eq^#(@x_1, @y_1),
#and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)),
#eq^#(@x_2, @y_2),
#eq^#(@x_3, @y_3))
, #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_35()
, #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_36()
, #eq^#(nil(), leaf()) -> c_37()
, #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_38()
, #eq^#(nil(), nil()) -> c_39()
, #eq^#(nil(), ::(@y_1, @y_2)) -> c_40()
, #eq^#(::(@x_1, @x_2), leaf()) -> c_41()
, #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_42()
, #eq^#(::(@x_1, @x_2), nil()) -> c_43()
, #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_44(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, #eq^#(#0(), #pos(@y)) -> c_45()
, #eq^#(#0(), #0()) -> c_46()
, #eq^#(#0(), #neg(@y)) -> c_47()
, #eq^#(#0(), #s(@y)) -> c_48()
, #eq^#(#neg(@x), #pos(@y)) -> c_49()
, #eq^#(#neg(@x), #0()) -> c_50()
, #eq^#(#neg(@x), #neg(@y)) -> c_51(#eq^#(@x, @y))
, #eq^#(#s(@x), #0()) -> c_52()
, #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y))
, bfs#4^#(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_2()
, appendreverse#1^#(nil(), @sofar) -> c_5()
, dfs#1^#(nil(), @x) -> c_8()
, bfs#2^#(nil(), @x) -> c_15()
, dfs#3^#(#true(), @t, @t1, @t2, @ts, @x) -> c_24()
, #and^#(#true(), #true()) -> c_54()
, #and^#(#true(), #false()) -> c_55()
, #and^#(#false(), #true()) -> c_56()
, #and^#(#false(), #false()) -> c_57() }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_3(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, bfs^#(@queue, @futurequeue, @x) ->
c_14(bfs#1^#(@queue, @futurequeue, @x))
, reverse^#(@xs) -> c_4(appendreverse^#(@xs, nil()))
, appendreverse^#(@toreverse, @sofar) ->
c_7(appendreverse#1^#(@toreverse, @sofar))
, appendreverse#1^#(::(@a, @as), @sofar) ->
c_6(appendreverse^#(@as, ::(@a, @sofar)))
, dfs#1^#(::(@t, @ts), @x) -> c_9(dfs#2^#(@t, @t, @ts, @x))
, dfs#2^#(leaf(), @t, @ts, @x) -> c_19(dfs^#(@ts, @x))
, dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_20(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x),
#equal^#(@a, @x))
, dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x))
, dodfs^#(@t, @x) -> c_11(dfs^#(::(@t, nil()), @x))
, dfs^#(@queue, @x) -> c_23(dfs#1^#(@queue, @x))
, bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, bfs#1^#(nil(), @futurequeue, @x) ->
c_17(bfs#2^#(@futurequeue, @x))
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_18(bfs#3^#(@t, @futurequeue, @ts, @x))
, bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_21(bfs^#(@ts, @futurequeue, @x))
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_22(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y),
#equal^#(@x, @y))
, dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_25(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dfs#1(nil(), @x) -> leaf()
, dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, dodfs(@t, @x) -> dfs(::(@t, nil()), @x)
, bfs2#1(@t', @x) -> dobfs(@t', @x)
, bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x)
, dfs#2(node(@a, @t1, @t2), @t, @ts, @x) ->
dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
, dfs(@queue, @x) -> dfs#1(@queue, @x)
, dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t
, dfs#3(#false(), @t, @t1, @t2, @ts, @x) ->
dfs(::(@t1, ::(@t2, @ts)), @x) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_20(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x),
#equal^#(@a, @x))
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_22(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y),
#equal^#(@x, @y)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x))
, reverse^#(@xs) -> c_3(appendreverse^#(@xs, nil()))
, appendreverse^#(@toreverse, @sofar) ->
c_4(appendreverse#1^#(@toreverse, @sofar))
, appendreverse#1^#(::(@a, @as), @sofar) ->
c_5(appendreverse^#(@as, ::(@a, @sofar)))
, dfs#1^#(::(@t, @ts), @x) -> c_6(dfs#2^#(@t, @t, @ts, @x))
, dfs#2^#(leaf(), @t, @ts, @x) -> c_7(dfs^#(@ts, @x))
, dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_8(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
, dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, dodfs^#(@t, @x) -> c_10(dfs^#(::(@t, nil()), @x))
, dfs^#(@queue, @x) -> c_11(dfs#1^#(@queue, @x))
, bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x))
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
, dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_19(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dfs#1(nil(), @x) -> leaf()
, dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, dodfs(@t, @x) -> dfs(::(@t, nil()), @x)
, bfs2#1(@t', @x) -> dobfs(@t', @x)
, bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x)
, dfs#2(node(@a, @t1, @t2), @t, @ts, @x) ->
dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
, dfs(@queue, @x) -> dfs#1(@queue, @x)
, dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t
, dfs#3(#false(), @t, @t1, @t2, @ts, @x) ->
dfs(::(@t1, ::(@t2, @ts)), @x) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We replace rewrite rules by usable rules:
Weak Usable Rules:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x))
, reverse^#(@xs) -> c_3(appendreverse^#(@xs, nil()))
, appendreverse^#(@toreverse, @sofar) ->
c_4(appendreverse#1^#(@toreverse, @sofar))
, appendreverse#1^#(::(@a, @as), @sofar) ->
c_5(appendreverse^#(@as, ::(@a, @sofar)))
, dfs#1^#(::(@t, @ts), @x) -> c_6(dfs#2^#(@t, @t, @ts, @x))
, dfs#2^#(leaf(), @t, @ts, @x) -> c_7(dfs^#(@ts, @x))
, dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_8(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
, dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, dodfs^#(@t, @x) -> c_10(dfs^#(::(@t, nil()), @x))
, dfs^#(@queue, @x) -> c_11(dfs#1^#(@queue, @x))
, bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x))
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
, dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_19(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
Consider the dependency graph
1: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
-->_1 bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x)) :2
2: bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x))
-->_1 bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x)) :15
-->_1 bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x)) :14
3: reverse^#(@xs) -> c_3(appendreverse^#(@xs, nil()))
-->_1 appendreverse^#(@toreverse, @sofar) ->
c_4(appendreverse#1^#(@toreverse, @sofar)) :4
4: appendreverse^#(@toreverse, @sofar) ->
c_4(appendreverse#1^#(@toreverse, @sofar))
-->_1 appendreverse#1^#(::(@a, @as), @sofar) ->
c_5(appendreverse^#(@as, ::(@a, @sofar))) :5
5: appendreverse#1^#(::(@a, @as), @sofar) ->
c_5(appendreverse^#(@as, ::(@a, @sofar)))
-->_1 appendreverse^#(@toreverse, @sofar) ->
c_4(appendreverse#1^#(@toreverse, @sofar)) :4
6: dfs#1^#(::(@t, @ts), @x) -> c_6(dfs#2^#(@t, @t, @ts, @x))
-->_1 dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_8(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x)) :8
-->_1 dfs#2^#(leaf(), @t, @ts, @x) -> c_7(dfs^#(@ts, @x)) :7
7: dfs#2^#(leaf(), @t, @ts, @x) -> c_7(dfs^#(@ts, @x))
-->_1 dfs^#(@queue, @x) -> c_11(dfs#1^#(@queue, @x)) :11
8: dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_8(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
-->_1 dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_19(dfs^#(::(@t1, ::(@t2, @ts)), @x)) :19
9: dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
-->_1 bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x)) :2
10: dodfs^#(@t, @x) -> c_10(dfs^#(::(@t, nil()), @x))
-->_1 dfs^#(@queue, @x) -> c_11(dfs#1^#(@queue, @x)) :11
11: dfs^#(@queue, @x) -> c_11(dfs#1^#(@queue, @x))
-->_1 dfs#1^#(::(@t, @ts), @x) -> c_6(dfs#2^#(@t, @t, @ts, @x)) :6
12: bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
-->_1 dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x)) :9
13: bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
-->_1 bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x)) :12
-->_2 dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x)) :9
14: bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
-->_1 bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts))) :16
15: bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
-->_1 bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y)) :18
-->_1 bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x)) :17
16: bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
-->_2 reverse^#(@xs) -> c_3(appendreverse^#(@xs, nil())) :3
-->_1 bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x)) :2
17: bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x))
-->_1 bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x)) :2
18: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
-->_1 bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) :1
19: dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_19(dfs^#(::(@t1, ::(@t2, @ts)), @x))
-->_1 dfs^#(@queue, @x) -> c_11(dfs#1^#(@queue, @x)) :11
Following roots of the dependency graph are removed, as the
considered set of starting terms is closed under reduction with
respect to these rules (modulo compound contexts).
{ dodfs^#(@t, @x) -> c_10(dfs^#(::(@t, nil()), @x)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x))
, reverse^#(@xs) -> c_3(appendreverse^#(@xs, nil()))
, appendreverse^#(@toreverse, @sofar) ->
c_4(appendreverse#1^#(@toreverse, @sofar))
, appendreverse#1^#(::(@a, @as), @sofar) ->
c_5(appendreverse^#(@as, ::(@a, @sofar)))
, dfs#1^#(::(@t, @ts), @x) -> c_6(dfs#2^#(@t, @t, @ts, @x))
, dfs#2^#(leaf(), @t, @ts, @x) -> c_7(dfs^#(@ts, @x))
, dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_8(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
, dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, dfs^#(@queue, @x) -> c_11(dfs#1^#(@queue, @x))
, bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x))
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
, dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_19(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We analyse the complexity of following sub-problems (R) and (S).
Problem (S) is obtained from the input problem by shifting strict
rules from (R) into the weak component:
Problem (R):
------------
Strict DPs:
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x))
, reverse^#(@xs) -> c_3(appendreverse^#(@xs, nil()))
, appendreverse^#(@toreverse, @sofar) ->
c_4(appendreverse#1^#(@toreverse, @sofar))
, appendreverse#1^#(::(@a, @as), @sofar) ->
c_5(appendreverse^#(@as, ::(@a, @sofar)))
, dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x))
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y)) }
Weak DPs:
{ dfs#1^#(::(@t, @ts), @x) -> c_6(dfs#2^#(@t, @t, @ts, @x))
, dfs#2^#(leaf(), @t, @ts, @x) -> c_7(dfs^#(@ts, @x))
, dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_8(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
, dfs^#(@queue, @x) -> c_11(dfs#1^#(@queue, @x))
, dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_19(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
StartTerms: basic terms
Strategy: innermost
Problem (S):
------------
Strict DPs:
{ dfs#1^#(::(@t, @ts), @x) -> c_6(dfs#2^#(@t, @t, @ts, @x))
, dfs#2^#(leaf(), @t, @ts, @x) -> c_7(dfs^#(@ts, @x))
, dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_8(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
, dfs^#(@queue, @x) -> c_11(dfs#1^#(@queue, @x))
, dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_19(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
Weak DPs:
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x))
, reverse^#(@xs) -> c_3(appendreverse^#(@xs, nil()))
, appendreverse^#(@toreverse, @sofar) ->
c_4(appendreverse#1^#(@toreverse, @sofar))
, appendreverse#1^#(::(@a, @as), @sofar) ->
c_5(appendreverse^#(@as, ::(@a, @sofar)))
, dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x))
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
StartTerms: basic terms
Strategy: innermost
Overall, the transformation results in the following sub-problem(s):
Generated new problems:
-----------------------
R) Strict DPs:
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x))
, reverse^#(@xs) -> c_3(appendreverse^#(@xs, nil()))
, appendreverse^#(@toreverse, @sofar) ->
c_4(appendreverse#1^#(@toreverse, @sofar))
, appendreverse#1^#(::(@a, @as), @sofar) ->
c_5(appendreverse^#(@as, ::(@a, @sofar)))
, dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x))
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y)) }
Weak DPs:
{ dfs#1^#(::(@t, @ts), @x) -> c_6(dfs#2^#(@t, @t, @ts, @x))
, dfs#2^#(leaf(), @t, @ts, @x) -> c_7(dfs^#(@ts, @x))
, dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_8(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
, dfs^#(@queue, @x) -> c_11(dfs#1^#(@queue, @x))
, dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_19(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
StartTerms: basic terms
Strategy: innermost
This problem was proven YES(O(1),O(n^2)).
S) Strict DPs:
{ dfs#1^#(::(@t, @ts), @x) -> c_6(dfs#2^#(@t, @t, @ts, @x))
, dfs#2^#(leaf(), @t, @ts, @x) -> c_7(dfs^#(@ts, @x))
, dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_8(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
, dfs^#(@queue, @x) -> c_11(dfs#1^#(@queue, @x))
, dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_19(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
Weak DPs:
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x))
, reverse^#(@xs) -> c_3(appendreverse^#(@xs, nil()))
, appendreverse^#(@toreverse, @sofar) ->
c_4(appendreverse#1^#(@toreverse, @sofar))
, appendreverse#1^#(::(@a, @as), @sofar) ->
c_5(appendreverse^#(@as, ::(@a, @sofar)))
, dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x))
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
StartTerms: basic terms
Strategy: innermost
This problem was proven YES(O(1),O(n^1)).
Proofs for generated problems:
------------------------------
R) We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x))
, reverse^#(@xs) -> c_3(appendreverse^#(@xs, nil()))
, appendreverse^#(@toreverse, @sofar) ->
c_4(appendreverse#1^#(@toreverse, @sofar))
, appendreverse#1^#(::(@a, @as), @sofar) ->
c_5(appendreverse^#(@as, ::(@a, @sofar)))
, dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x))
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y)) }
Weak DPs:
{ dfs#1^#(::(@t, @ts), @x) -> c_6(dfs#2^#(@t, @t, @ts, @x))
, dfs#2^#(leaf(), @t, @ts, @x) -> c_7(dfs^#(@ts, @x))
, dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_8(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
, dfs^#(@queue, @x) -> c_11(dfs#1^#(@queue, @x))
, dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_19(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
The following weak DPs constitute a sub-graph of the DG that is
closed under successors. The DPs are removed.
{ dfs#1^#(::(@t, @ts), @x) -> c_6(dfs#2^#(@t, @t, @ts, @x))
, dfs#2^#(leaf(), @t, @ts, @x) -> c_7(dfs^#(@ts, @x))
, dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_8(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
, dfs^#(@queue, @x) -> c_11(dfs#1^#(@queue, @x))
, dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_19(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x))
, reverse^#(@xs) -> c_3(appendreverse^#(@xs, nil()))
, appendreverse^#(@toreverse, @sofar) ->
c_4(appendreverse#1^#(@toreverse, @sofar))
, appendreverse#1^#(::(@a, @as), @sofar) ->
c_5(appendreverse^#(@as, ::(@a, @sofar)))
, dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x))
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We decompose the input problem according to the dependency graph
into the upper component
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x))
, dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x))
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y)) }
and lower component
{ reverse^#(@xs) -> c_3(appendreverse^#(@xs, nil()))
, appendreverse^#(@toreverse, @sofar) ->
c_4(appendreverse#1^#(@toreverse, @sofar))
, appendreverse#1^#(::(@a, @as), @sofar) ->
c_5(appendreverse^#(@as, ::(@a, @sofar))) }
Further, following extension rules are added to the lower
component.
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, bfs^#(@queue, @futurequeue, @x) ->
bfs#1^#(@queue, @futurequeue, @x)
, dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x)
, bfs2#1^#(@t', @x) -> dobfs^#(@t', @x)
, bfs2^#(@t, @x) -> dobfs^#(@t, @x)
, bfs2^#(@t, @x) -> bfs2#1^#(dobfs(@t, @x), @x)
, bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x)
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
bfs#3^#(@t, @futurequeue, @ts, @x)
, bfs#2^#(::(@t, @ts), @x) ->
bfs^#(reverse(::(@t, @ts)), nil(), @x)
, bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
bfs^#(@ts, @futurequeue, @x)
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
TcT solves the upper component with certificate YES(O(1),O(n^1)).
Sub-proof:
----------
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x))
, dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x))
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We use the processor 'matrix interpretation of dimension 1' to
orient following rules strictly.
DPs:
{ 1: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, 9: bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x)) }
Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #and(#true(), #true()) -> #true()
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x) }
Sub-proof:
----------
The following argument positions are usable:
Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_9) = {1},
Uargs(c_12) = {1}, Uargs(c_13) = {1, 2}, Uargs(c_14) = {1},
Uargs(c_15) = {1}, Uargs(c_16) = {1}, Uargs(c_17) = {1},
Uargs(c_18) = {1}
TcT has computed the following constructor-based matrix
interpretation satisfying not(EDA).
[#equal](x1, x2) = [3] x2 + [3]
[bfs#4](x1, x2, x3, x4, x5, x6, x7) = [1] x2 + [1] x3 + [1] x4 + [1] x5 + [5]
[#eq](x1, x2) = [2] x2 + [1]
[reverse](x1) = [1] x1 + [0]
[appendreverse#1](x1, x2) = [1] x1 + [1] x2 + [0]
[appendreverse](x1, x2) = [1] x1 + [1] x2 + [0]
[#true] = [0]
[leaf] = [1]
[dobfs](x1, x2) = [2] x1 + [3]
[#pos](x1) = [1] x1 + [0]
[node](x1, x2, x3) = [1] x2 + [1] x3 + [3]
[bfs](x1, x2, x3) = [1] x1 + [1] x2 + [1]
[#and](x1, x2) = [1]
[nil] = [0]
[bfs#2](x1, x2) = [1] x1 + [1]
[#false] = [1]
[::](x1, x2) = [1] x1 + [1] x2 + [2]
[bfs#1](x1, x2, x3) = [1] x1 + [1] x2 + [1]
[bfs#3](x1, x2, x3, x4) = [1] x1 + [1] x2 + [1] x3 + [2]
[#0] = [0]
[#neg](x1) = [1] x1 + [0]
[#s](x1) = [1] x1 + [0]
[bfs#4^#](x1, x2, x3, x4, x5, x6, x7) = [1] x2 + [1] x3 + [1] x4 + [1] x5 + [5]
[bfs^#](x1, x2, x3) = [1] x1 + [1] x2 + [0]
[reverse^#](x1) = [0]
[dobfs^#](x1, x2) = [1] x1 + [2]
[bfs2#1^#](x1, x2) = [1] x1 + [4] x2 + [2]
[bfs2^#](x1, x2) = [7] x1 + [7] x2 + [7]
[bfs#1^#](x1, x2, x3) = [1] x1 + [1] x2 + [0]
[bfs#2^#](x1, x2) = [1] x1 + [0]
[bfs#3^#](x1, x2, x3, x4) = [1] x1 + [1] x2 + [1] x3 + [2]
[c_1](x1) = [1] x1 + [0]
[c_2](x1) = [1] x1 + [0]
[c_9](x1) = [1] x1 + [0]
[c_12](x1) = [1] x1 + [0]
[c_13](x1, x2) = [1] x1 + [1] x2 + [0]
[c_14](x1) = [1] x1 + [0]
[c_15](x1) = [1] x1 + [0]
[c_16](x1, x2) = [1] x1 + [1] x2 + [0]
[c_17](x1) = [1] x1 + [1]
[c_18](x1) = [1] x1 + [0]
The order satisfies the following ordering constraints:
[#equal(@x, @y)] = [3] @y + [3]
> [2] @y + [1]
= [#eq(@x, @y)]
[bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [5]
> [1] @t1 + [1] @t2 + [3]
= [node(@y, @t1, @t2)]
[bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [5]
>= [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [5]
= [bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)]
[#eq(leaf(), leaf())] = [3]
> [0]
= [#true()]
[#eq(leaf(), node(@y_1, @y_2, @y_3))] = [2] @y_2 + [2] @y_3 + [7]
> [1]
= [#false()]
[#eq(leaf(), nil())] = [1]
>= [1]
= [#false()]
[#eq(leaf(), ::(@y_1, @y_2))] = [2] @y_1 + [2] @y_2 + [5]
> [1]
= [#false()]
[#eq(#pos(@x), #pos(@y))] = [2] @y + [1]
>= [2] @y + [1]
= [#eq(@x, @y)]
[#eq(#pos(@x), #0())] = [1]
>= [1]
= [#false()]
[#eq(#pos(@x), #neg(@y))] = [2] @y + [1]
>= [1]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), leaf())] = [3]
> [1]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3))] = [2] @y_2 + [2] @y_3 + [7]
> [1]
= [#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))]
[#eq(node(@x_1, @x_2, @x_3), nil())] = [1]
>= [1]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2))] = [2] @y_1 + [2] @y_2 + [5]
> [1]
= [#false()]
[#eq(nil(), leaf())] = [3]
> [1]
= [#false()]
[#eq(nil(), node(@y_1, @y_2, @y_3))] = [2] @y_2 + [2] @y_3 + [7]
> [1]
= [#false()]
[#eq(nil(), nil())] = [1]
> [0]
= [#true()]
[#eq(nil(), ::(@y_1, @y_2))] = [2] @y_1 + [2] @y_2 + [5]
> [1]
= [#false()]
[#eq(::(@x_1, @x_2), leaf())] = [3]
> [1]
= [#false()]
[#eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3))] = [2] @y_2 + [2] @y_3 + [7]
> [1]
= [#false()]
[#eq(::(@x_1, @x_2), nil())] = [1]
>= [1]
= [#false()]
[#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [2] @y_1 + [2] @y_2 + [5]
> [1]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(#0(), #pos(@y))] = [2] @y + [1]
>= [1]
= [#false()]
[#eq(#0(), #0())] = [1]
> [0]
= [#true()]
[#eq(#0(), #neg(@y))] = [2] @y + [1]
>= [1]
= [#false()]
[#eq(#0(), #s(@y))] = [2] @y + [1]
>= [1]
= [#false()]
[#eq(#neg(@x), #pos(@y))] = [2] @y + [1]
>= [1]
= [#false()]
[#eq(#neg(@x), #0())] = [1]
>= [1]
= [#false()]
[#eq(#neg(@x), #neg(@y))] = [2] @y + [1]
>= [2] @y + [1]
= [#eq(@x, @y)]
[#eq(#s(@x), #0())] = [1]
>= [1]
= [#false()]
[#eq(#s(@x), #s(@y))] = [2] @y + [1]
>= [2] @y + [1]
= [#eq(@x, @y)]
[reverse(@xs)] = [1] @xs + [0]
>= [1] @xs + [0]
= [appendreverse(@xs, nil())]
[appendreverse#1(nil(), @sofar)] = [1] @sofar + [0]
>= [1] @sofar + [0]
= [@sofar]
[appendreverse#1(::(@a, @as), @sofar)] = [1] @sofar + [1] @a + [1] @as + [2]
>= [1] @sofar + [1] @a + [1] @as + [2]
= [appendreverse(@as, ::(@a, @sofar))]
[appendreverse(@toreverse, @sofar)] = [1] @toreverse + [1] @sofar + [0]
>= [1] @toreverse + [1] @sofar + [0]
= [appendreverse#1(@toreverse, @sofar)]
[dobfs(@t, @x)] = [2] @t + [3]
>= [1] @t + [3]
= [bfs(::(@t, nil()), nil(), @x)]
[bfs(@queue, @futurequeue, @x)] = [1] @queue + [1] @futurequeue + [1]
>= [1] @queue + [1] @futurequeue + [1]
= [bfs#1(@queue, @futurequeue, @x)]
[#and(#true(), #true())] = [1]
> [0]
= [#true()]
[#and(#true(), #false())] = [1]
>= [1]
= [#false()]
[#and(#false(), #true())] = [1]
>= [1]
= [#false()]
[#and(#false(), #false())] = [1]
>= [1]
= [#false()]
[bfs#2(nil(), @x)] = [1]
>= [1]
= [leaf()]
[bfs#2(::(@t, @ts), @x)] = [1] @t + [1] @ts + [3]
>= [1] @t + [1] @ts + [3]
= [bfs(reverse(::(@t, @ts)), nil(), @x)]
[bfs#1(nil(), @futurequeue, @x)] = [1] @futurequeue + [1]
>= [1] @futurequeue + [1]
= [bfs#2(@futurequeue, @x)]
[bfs#1(::(@t, @ts), @futurequeue, @x)] = [1] @futurequeue + [1] @t + [1] @ts + [3]
> [1] @futurequeue + [1] @t + [1] @ts + [2]
= [bfs#3(@t, @futurequeue, @ts, @x)]
[bfs#3(leaf(), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @ts + [3]
> [1] @futurequeue + [1] @ts + [1]
= [bfs(@ts, @futurequeue, @x)]
[bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [5]
>= [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [5]
= [bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)]
[bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [5]
> [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [4]
= [c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))]
[bfs^#(@queue, @futurequeue, @x)] = [1] @queue + [1] @futurequeue + [0]
>= [1] @queue + [1] @futurequeue + [0]
= [c_2(bfs#1^#(@queue, @futurequeue, @x))]
[dobfs^#(@t, @x)] = [1] @t + [2]
>= [1] @t + [2]
= [c_9(bfs^#(::(@t, nil()), nil(), @x))]
[bfs2#1^#(@t', @x)] = [4] @x + [1] @t' + [2]
>= [1] @t' + [2]
= [c_12(dobfs^#(@t', @x))]
[bfs2^#(@t, @x)] = [7] @x + [7] @t + [7]
>= [4] @x + [3] @t + [7]
= [c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))]
[bfs#1^#(nil(), @futurequeue, @x)] = [1] @futurequeue + [0]
>= [1] @futurequeue + [0]
= [c_14(bfs#2^#(@futurequeue, @x))]
[bfs#1^#(::(@t, @ts), @futurequeue, @x)] = [1] @futurequeue + [1] @t + [1] @ts + [2]
>= [1] @futurequeue + [1] @t + [1] @ts + [2]
= [c_15(bfs#3^#(@t, @futurequeue, @ts, @x))]
[bfs#2^#(::(@t, @ts), @x)] = [1] @t + [1] @ts + [2]
>= [1] @t + [1] @ts + [2]
= [c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))]
[bfs#3^#(leaf(), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @ts + [3]
> [1] @futurequeue + [1] @ts + [1]
= [c_17(bfs^#(@ts, @futurequeue, @x))]
[bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [5]
>= [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [5]
= [c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y))]
We return to the main proof. Consider the set of all dependency
pairs
:
{ 1: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, 2: bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x))
, 3: dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, 4: bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, 5: bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, 6: bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, 7: bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, 8: bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, 9: bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x))
, 10: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y)) }
Processor 'matrix interpretation of dimension 1' induces the
complexity certificate YES(?,O(n^1)) on application of dependency
pairs {1,9}. These cover all (indirect) predecessors of dependency
pairs {1,3,4,5,9}, their number of application is equally bounded.
The dependency pairs are shifted into the weak component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x))
, bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y)) }
Weak DPs:
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We use the processor 'matrix interpretation of dimension 1' to
orient following rules strictly.
DPs:
{ 5: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
, 6: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, 7: dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, 9: bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) }
Trs:
{ bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) }
Sub-proof:
----------
The following argument positions are usable:
Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_9) = {1},
Uargs(c_12) = {1}, Uargs(c_13) = {1, 2}, Uargs(c_14) = {1},
Uargs(c_15) = {1}, Uargs(c_16) = {1}, Uargs(c_17) = {1},
Uargs(c_18) = {1}
TcT has computed the following constructor-based matrix
interpretation satisfying not(EDA).
[#equal](x1, x2) = [6]
[bfs#4](x1, x2, x3, x4, x5, x6, x7) = [1] x1 + [1] x2 + [1] x3 + [1] x4 + [1] x5 + [0]
[#eq](x1, x2) = [6]
[reverse](x1) = [1] x1 + [0]
[appendreverse#1](x1, x2) = [1] x1 + [1] x2 + [0]
[appendreverse](x1, x2) = [1] x1 + [1] x2 + [0]
[#true] = [6]
[leaf] = [0]
[dobfs](x1, x2) = [1] x1 + [0]
[#pos](x1) = [1] x1 + [0]
[node](x1, x2, x3) = [1] x2 + [1] x3 + [6]
[bfs](x1, x2, x3) = [1] x1 + [1] x2 + [0]
[#and](x1, x2) = [6]
[nil] = [0]
[bfs#2](x1, x2) = [1] x1 + [0]
[#false] = [6]
[::](x1, x2) = [1] x1 + [1] x2 + [0]
[bfs#1](x1, x2, x3) = [1] x1 + [1] x2 + [0]
[bfs#3](x1, x2, x3, x4) = [1] x1 + [1] x2 + [1] x3 + [0]
[#0] = [0]
[#neg](x1) = [1] x1 + [0]
[#s](x1) = [1] x1 + [0]
[bfs#4^#](x1, x2, x3, x4, x5, x6, x7) = [2] x1 + [2] x2 + [2] x3 + [2] x4 + [2] x5 + [0]
[bfs^#](x1, x2, x3) = [2] x1 + [2] x2 + [1]
[reverse^#](x1) = [0]
[dobfs^#](x1, x2) = [2] x1 + [2]
[bfs2#1^#](x1, x2) = [2] x1 + [2] x2 + [2]
[bfs2^#](x1, x2) = [7] x1 + [7] x2 + [7]
[bfs#1^#](x1, x2, x3) = [2] x1 + [2] x2 + [1]
[bfs#2^#](x1, x2) = [2] x1 + [1]
[bfs#3^#](x1, x2, x3, x4) = [2] x1 + [2] x2 + [2] x3 + [1]
[c_1](x1) = [1] x1 + [3]
[c_2](x1) = [1] x1 + [0]
[c_9](x1) = [1] x1 + [0]
[c_12](x1) = [1] x1 + [0]
[c_13](x1, x2) = [2] x1 + [1] x2 + [0]
[c_14](x1) = [1] x1 + [0]
[c_15](x1) = [1] x1 + [0]
[c_16](x1, x2) = [1] x1 + [1] x2 + [0]
[c_17](x1) = [1] x1 + [0]
[c_18](x1) = [1] x1 + [0]
The order satisfies the following ordering constraints:
[#equal(@x, @y)] = [6]
>= [6]
= [#eq(@x, @y)]
[bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [6]
>= [1] @t1 + [1] @t2 + [6]
= [node(@y, @t1, @t2)]
[bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [6]
> [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [0]
= [bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)]
[#eq(leaf(), leaf())] = [6]
>= [6]
= [#true()]
[#eq(leaf(), node(@y_1, @y_2, @y_3))] = [6]
>= [6]
= [#false()]
[#eq(leaf(), nil())] = [6]
>= [6]
= [#false()]
[#eq(leaf(), ::(@y_1, @y_2))] = [6]
>= [6]
= [#false()]
[#eq(#pos(@x), #pos(@y))] = [6]
>= [6]
= [#eq(@x, @y)]
[#eq(#pos(@x), #0())] = [6]
>= [6]
= [#false()]
[#eq(#pos(@x), #neg(@y))] = [6]
>= [6]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), leaf())] = [6]
>= [6]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3))] = [6]
>= [6]
= [#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))]
[#eq(node(@x_1, @x_2, @x_3), nil())] = [6]
>= [6]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2))] = [6]
>= [6]
= [#false()]
[#eq(nil(), leaf())] = [6]
>= [6]
= [#false()]
[#eq(nil(), node(@y_1, @y_2, @y_3))] = [6]
>= [6]
= [#false()]
[#eq(nil(), nil())] = [6]
>= [6]
= [#true()]
[#eq(nil(), ::(@y_1, @y_2))] = [6]
>= [6]
= [#false()]
[#eq(::(@x_1, @x_2), leaf())] = [6]
>= [6]
= [#false()]
[#eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3))] = [6]
>= [6]
= [#false()]
[#eq(::(@x_1, @x_2), nil())] = [6]
>= [6]
= [#false()]
[#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [6]
>= [6]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(#0(), #pos(@y))] = [6]
>= [6]
= [#false()]
[#eq(#0(), #0())] = [6]
>= [6]
= [#true()]
[#eq(#0(), #neg(@y))] = [6]
>= [6]
= [#false()]
[#eq(#0(), #s(@y))] = [6]
>= [6]
= [#false()]
[#eq(#neg(@x), #pos(@y))] = [6]
>= [6]
= [#false()]
[#eq(#neg(@x), #0())] = [6]
>= [6]
= [#false()]
[#eq(#neg(@x), #neg(@y))] = [6]
>= [6]
= [#eq(@x, @y)]
[#eq(#s(@x), #0())] = [6]
>= [6]
= [#false()]
[#eq(#s(@x), #s(@y))] = [6]
>= [6]
= [#eq(@x, @y)]
[reverse(@xs)] = [1] @xs + [0]
>= [1] @xs + [0]
= [appendreverse(@xs, nil())]
[appendreverse#1(nil(), @sofar)] = [1] @sofar + [0]
>= [1] @sofar + [0]
= [@sofar]
[appendreverse#1(::(@a, @as), @sofar)] = [1] @sofar + [1] @a + [1] @as + [0]
>= [1] @sofar + [1] @a + [1] @as + [0]
= [appendreverse(@as, ::(@a, @sofar))]
[appendreverse(@toreverse, @sofar)] = [1] @toreverse + [1] @sofar + [0]
>= [1] @toreverse + [1] @sofar + [0]
= [appendreverse#1(@toreverse, @sofar)]
[dobfs(@t, @x)] = [1] @t + [0]
>= [1] @t + [0]
= [bfs(::(@t, nil()), nil(), @x)]
[bfs(@queue, @futurequeue, @x)] = [1] @queue + [1] @futurequeue + [0]
>= [1] @queue + [1] @futurequeue + [0]
= [bfs#1(@queue, @futurequeue, @x)]
[#and(#true(), #true())] = [6]
>= [6]
= [#true()]
[#and(#true(), #false())] = [6]
>= [6]
= [#false()]
[#and(#false(), #true())] = [6]
>= [6]
= [#false()]
[#and(#false(), #false())] = [6]
>= [6]
= [#false()]
[bfs#2(nil(), @x)] = [0]
>= [0]
= [leaf()]
[bfs#2(::(@t, @ts), @x)] = [1] @t + [1] @ts + [0]
>= [1] @t + [1] @ts + [0]
= [bfs(reverse(::(@t, @ts)), nil(), @x)]
[bfs#1(nil(), @futurequeue, @x)] = [1] @futurequeue + [0]
>= [1] @futurequeue + [0]
= [bfs#2(@futurequeue, @x)]
[bfs#1(::(@t, @ts), @futurequeue, @x)] = [1] @futurequeue + [1] @t + [1] @ts + [0]
>= [1] @futurequeue + [1] @t + [1] @ts + [0]
= [bfs#3(@t, @futurequeue, @ts, @x)]
[bfs#3(leaf(), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @ts + [0]
>= [1] @futurequeue + [1] @ts + [0]
= [bfs(@ts, @futurequeue, @x)]
[bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [6]
>= [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [6]
= [bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)]
[bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [2] @futurequeue + [2] @ts + [2] @t1 + [2] @t2 + [12]
> [2] @futurequeue + [2] @ts + [2] @t1 + [2] @t2 + [4]
= [c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))]
[bfs^#(@queue, @futurequeue, @x)] = [2] @queue + [2] @futurequeue + [1]
>= [2] @queue + [2] @futurequeue + [1]
= [c_2(bfs#1^#(@queue, @futurequeue, @x))]
[dobfs^#(@t, @x)] = [2] @t + [2]
> [2] @t + [1]
= [c_9(bfs^#(::(@t, nil()), nil(), @x))]
[bfs2#1^#(@t', @x)] = [2] @x + [2] @t' + [2]
>= [2] @t' + [2]
= [c_12(dobfs^#(@t', @x))]
[bfs2^#(@t, @x)] = [7] @x + [7] @t + [7]
> [4] @x + [6] @t + [6]
= [c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))]
[bfs#1^#(nil(), @futurequeue, @x)] = [2] @futurequeue + [1]
>= [2] @futurequeue + [1]
= [c_14(bfs#2^#(@futurequeue, @x))]
[bfs#1^#(::(@t, @ts), @futurequeue, @x)] = [2] @futurequeue + [2] @t + [2] @ts + [1]
>= [2] @futurequeue + [2] @t + [2] @ts + [1]
= [c_15(bfs#3^#(@t, @futurequeue, @ts, @x))]
[bfs#2^#(::(@t, @ts), @x)] = [2] @t + [2] @ts + [1]
>= [2] @t + [2] @ts + [1]
= [c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))]
[bfs#3^#(leaf(), @futurequeue, @ts, @x)] = [2] @futurequeue + [2] @ts + [1]
>= [2] @futurequeue + [2] @ts + [1]
= [c_17(bfs^#(@ts, @futurequeue, @x))]
[bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [2] @futurequeue + [2] @ts + [2] @t1 + [2] @t2 + [13]
> [2] @futurequeue + [2] @ts + [2] @t1 + [2] @t2 + [12]
= [c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y))]
We return to the main proof. Consider the set of all dependency
pairs
:
{ 1: bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x))
, 2: bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, 3: bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, 4: bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, 5: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
, 6: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, 7: dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, 8: bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, 9: bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, 10: bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x)) }
Processor 'matrix interpretation of dimension 1' induces the
complexity certificate YES(?,O(n^1)) on application of dependency
pairs {5,6,7,9}. These cover all (indirect) predecessors of
dependency pairs {5,6,7,8,9}, their number of application is
equally bounded. The dependency pairs are shifted into the weak
component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x))
, bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts))) }
Weak DPs:
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x))
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We use the processor 'matrix interpretation of dimension 1' to
orient following rules strictly.
DPs:
{ 3: bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, 6: dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, 10: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y)) }
Trs:
{ bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(nil(), nil()) -> #true()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x) }
Sub-proof:
----------
The following argument positions are usable:
Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_9) = {1},
Uargs(c_12) = {1}, Uargs(c_13) = {1, 2}, Uargs(c_14) = {1},
Uargs(c_15) = {1}, Uargs(c_16) = {1}, Uargs(c_17) = {1},
Uargs(c_18) = {1}
TcT has computed the following constructor-based matrix
interpretation satisfying not(EDA).
[#equal](x1, x2) = [1] x1 + [1] x2 + [3]
[bfs#4](x1, x2, x3, x4, x5, x6, x7) = [1] x2 + [1] x3 + [1] x4 + [1] x5 + [4]
[#eq](x1, x2) = [3]
[reverse](x1) = [1] x1 + [0]
[appendreverse#1](x1, x2) = [1] x1 + [1] x2 + [0]
[appendreverse](x1, x2) = [1] x1 + [1] x2 + [0]
[#true] = [0]
[leaf] = [0]
[dobfs](x1, x2) = [1] x1 + [1]
[#pos](x1) = [1] x1 + [0]
[node](x1, x2, x3) = [1] x2 + [1] x3 + [4]
[bfs](x1, x2, x3) = [1] x1 + [1] x2 + [0]
[#and](x1, x2) = [0]
[nil] = [0]
[bfs#2](x1, x2) = [1] x1 + [0]
[#false] = [4]
[::](x1, x2) = [1] x1 + [1] x2 + [1]
[bfs#1](x1, x2, x3) = [1] x1 + [1] x2 + [0]
[bfs#3](x1, x2, x3, x4) = [1] x1 + [1] x2 + [1] x3 + [0]
[#0] = [0]
[#neg](x1) = [1] x1 + [0]
[#s](x1) = [1] x1 + [0]
[bfs#4^#](x1, x2, x3, x4, x5, x6, x7) = [1] x2 + [1] x3 + [1] x4 + [1] x5 + [3]
[bfs^#](x1, x2, x3) = [1] x1 + [1] x2 + [1]
[reverse^#](x1) = [0]
[dobfs^#](x1, x2) = [1] x1 + [3]
[bfs2#1^#](x1, x2) = [1] x1 + [4] x2 + [3]
[bfs2^#](x1, x2) = [7] x1 + [7] x2 + [7]
[bfs#1^#](x1, x2, x3) = [1] x1 + [1] x2 + [1]
[bfs#2^#](x1, x2) = [1] x1 + [1]
[bfs#3^#](x1, x2, x3, x4) = [1] x1 + [1] x2 + [1] x3 + [1]
[c_1](x1) = [1] x1 + [0]
[c_2](x1) = [1] x1 + [0]
[c_9](x1) = [1] x1 + [0]
[c_12](x1) = [1] x1 + [0]
[c_13](x1, x2) = [1] x1 + [1] x2 + [0]
[c_14](x1) = [1] x1 + [0]
[c_15](x1) = [1] x1 + [0]
[c_16](x1, x2) = [1] x1 + [1] x2 + [0]
[c_17](x1) = [1] x1 + [0]
[c_18](x1) = [1] x1 + [0]
The order satisfies the following ordering constraints:
[#equal(@x, @y)] = [1] @x + [1] @y + [3]
>= [3]
= [#eq(@x, @y)]
[bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [4]
>= [1] @t1 + [1] @t2 + [4]
= [node(@y, @t1, @t2)]
[bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [4]
> [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [2]
= [bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)]
[#eq(leaf(), leaf())] = [3]
> [0]
= [#true()]
[#eq(leaf(), node(@y_1, @y_2, @y_3))] = [3]
? [4]
= [#false()]
[#eq(leaf(), nil())] = [3]
? [4]
= [#false()]
[#eq(leaf(), ::(@y_1, @y_2))] = [3]
? [4]
= [#false()]
[#eq(#pos(@x), #pos(@y))] = [3]
>= [3]
= [#eq(@x, @y)]
[#eq(#pos(@x), #0())] = [3]
? [4]
= [#false()]
[#eq(#pos(@x), #neg(@y))] = [3]
? [4]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), leaf())] = [3]
? [4]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3))] = [3]
> [0]
= [#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))]
[#eq(node(@x_1, @x_2, @x_3), nil())] = [3]
? [4]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2))] = [3]
? [4]
= [#false()]
[#eq(nil(), leaf())] = [3]
? [4]
= [#false()]
[#eq(nil(), node(@y_1, @y_2, @y_3))] = [3]
? [4]
= [#false()]
[#eq(nil(), nil())] = [3]
> [0]
= [#true()]
[#eq(nil(), ::(@y_1, @y_2))] = [3]
? [4]
= [#false()]
[#eq(::(@x_1, @x_2), leaf())] = [3]
? [4]
= [#false()]
[#eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3))] = [3]
? [4]
= [#false()]
[#eq(::(@x_1, @x_2), nil())] = [3]
? [4]
= [#false()]
[#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [3]
> [0]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(#0(), #pos(@y))] = [3]
? [4]
= [#false()]
[#eq(#0(), #0())] = [3]
> [0]
= [#true()]
[#eq(#0(), #neg(@y))] = [3]
? [4]
= [#false()]
[#eq(#0(), #s(@y))] = [3]
? [4]
= [#false()]
[#eq(#neg(@x), #pos(@y))] = [3]
? [4]
= [#false()]
[#eq(#neg(@x), #0())] = [3]
? [4]
= [#false()]
[#eq(#neg(@x), #neg(@y))] = [3]
>= [3]
= [#eq(@x, @y)]
[#eq(#s(@x), #0())] = [3]
? [4]
= [#false()]
[#eq(#s(@x), #s(@y))] = [3]
>= [3]
= [#eq(@x, @y)]
[reverse(@xs)] = [1] @xs + [0]
>= [1] @xs + [0]
= [appendreverse(@xs, nil())]
[appendreverse#1(nil(), @sofar)] = [1] @sofar + [0]
>= [1] @sofar + [0]
= [@sofar]
[appendreverse#1(::(@a, @as), @sofar)] = [1] @sofar + [1] @a + [1] @as + [1]
>= [1] @sofar + [1] @a + [1] @as + [1]
= [appendreverse(@as, ::(@a, @sofar))]
[appendreverse(@toreverse, @sofar)] = [1] @toreverse + [1] @sofar + [0]
>= [1] @toreverse + [1] @sofar + [0]
= [appendreverse#1(@toreverse, @sofar)]
[dobfs(@t, @x)] = [1] @t + [1]
>= [1] @t + [1]
= [bfs(::(@t, nil()), nil(), @x)]
[bfs(@queue, @futurequeue, @x)] = [1] @queue + [1] @futurequeue + [0]
>= [1] @queue + [1] @futurequeue + [0]
= [bfs#1(@queue, @futurequeue, @x)]
[#and(#true(), #true())] = [0]
>= [0]
= [#true()]
[#and(#true(), #false())] = [0]
? [4]
= [#false()]
[#and(#false(), #true())] = [0]
? [4]
= [#false()]
[#and(#false(), #false())] = [0]
? [4]
= [#false()]
[bfs#2(nil(), @x)] = [0]
>= [0]
= [leaf()]
[bfs#2(::(@t, @ts), @x)] = [1] @t + [1] @ts + [1]
>= [1] @t + [1] @ts + [1]
= [bfs(reverse(::(@t, @ts)), nil(), @x)]
[bfs#1(nil(), @futurequeue, @x)] = [1] @futurequeue + [0]
>= [1] @futurequeue + [0]
= [bfs#2(@futurequeue, @x)]
[bfs#1(::(@t, @ts), @futurequeue, @x)] = [1] @futurequeue + [1] @t + [1] @ts + [1]
> [1] @futurequeue + [1] @t + [1] @ts + [0]
= [bfs#3(@t, @futurequeue, @ts, @x)]
[bfs#3(leaf(), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @ts + [0]
>= [1] @futurequeue + [1] @ts + [0]
= [bfs(@ts, @futurequeue, @x)]
[bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [4]
>= [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [4]
= [bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)]
[bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [3]
>= [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [3]
= [c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))]
[bfs^#(@queue, @futurequeue, @x)] = [1] @queue + [1] @futurequeue + [1]
>= [1] @queue + [1] @futurequeue + [1]
= [c_2(bfs#1^#(@queue, @futurequeue, @x))]
[dobfs^#(@t, @x)] = [1] @t + [3]
> [1] @t + [2]
= [c_9(bfs^#(::(@t, nil()), nil(), @x))]
[bfs2#1^#(@t', @x)] = [4] @x + [1] @t' + [3]
>= [1] @t' + [3]
= [c_12(dobfs^#(@t', @x))]
[bfs2^#(@t, @x)] = [7] @x + [7] @t + [7]
>= [4] @x + [2] @t + [7]
= [c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))]
[bfs#1^#(nil(), @futurequeue, @x)] = [1] @futurequeue + [1]
>= [1] @futurequeue + [1]
= [c_14(bfs#2^#(@futurequeue, @x))]
[bfs#1^#(::(@t, @ts), @futurequeue, @x)] = [1] @futurequeue + [1] @t + [1] @ts + [2]
> [1] @futurequeue + [1] @t + [1] @ts + [1]
= [c_15(bfs#3^#(@t, @futurequeue, @ts, @x))]
[bfs#2^#(::(@t, @ts), @x)] = [1] @t + [1] @ts + [2]
>= [1] @t + [1] @ts + [2]
= [c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))]
[bfs#3^#(leaf(), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @ts + [1]
>= [1] @futurequeue + [1] @ts + [1]
= [c_17(bfs^#(@ts, @futurequeue, @x))]
[bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [5]
> [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [3]
= [c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y))]
We return to the main proof. Consider the set of all dependency
pairs
:
{ 1: bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x))
, 2: bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, 3: bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, 4: bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, 5: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, 6: dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, 7: bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, 8: bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, 9: bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x))
, 10: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y)) }
Processor 'matrix interpretation of dimension 1' induces the
complexity certificate YES(?,O(n^1)) on application of dependency
pairs {3,6,10}. These cover all (indirect) predecessors of
dependency pairs {3,5,6,7,8,9,10}, their number of application is
equally bounded. The dependency pairs are shifted into the weak
component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x))
, bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts))) }
Weak DPs:
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x))
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We use the processor 'matrix interpretation of dimension 2' to
orient following rules strictly.
DPs:
{ 2: bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, 3: bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, 4: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, 6: bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, 10: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y)) }
Trs:
{ bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#s(@x), #0()) -> #false()
, #and(#true(), #true()) -> #true()
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
Sub-proof:
----------
The following argument positions are usable:
Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_9) = {1},
Uargs(c_12) = {1}, Uargs(c_13) = {1, 2}, Uargs(c_14) = {1},
Uargs(c_15) = {1}, Uargs(c_16) = {1}, Uargs(c_17) = {1},
Uargs(c_18) = {1}
TcT has computed the following constructor-based matrix
interpretation satisfying not(EDA) and not(IDA(1)).
[#equal](x1, x2) = [4]
[1]
[bfs#4](x1, x2, x3, x4, x5, x6, x7) = [0 2] x2 + [2 2] x3 + [2
1] x4 + [0 2] x5 + [7]
[0 0] [0 0] [0
0] [0 0] [0]
[#eq](x1, x2) = [4]
[1]
[reverse](x1) = [5 1] x1 + [0]
[0 1] [0]
[appendreverse#1](x1, x2) = [2 1] x1 + [2 0] x2 + [0]
[0 1] [0 1] [0]
[appendreverse](x1, x2) = [2 1] x1 + [2 0] x2 + [0]
[0 1] [0 1] [0]
[#true] = [0]
[1]
[leaf] = [0]
[0]
[dobfs](x1, x2) = [2 0] x1 + [0 0] x2 + [0]
[0 0] [1 0] [0]
[#pos](x1) = [1 0] x1 + [0]
[0 1] [0]
[node](x1, x2, x3) = [1 1] x2 + [1 1] x3 + [6]
[0 0] [0 0] [0]
[bfs](x1, x2, x3) = [0 2] x1 + [0 2] x2 + [0]
[0 0] [0 0] [0]
[#and](x1, x2) = [0 1] x1 + [1]
[0 0] [1]
[nil] = [0]
[0]
[bfs#2](x1, x2) = [0 2] x1 + [0]
[0 0] [0]
[#false] = [2]
[1]
[::](x1, x2) = [0 1] x1 + [1 0] x2 + [4]
[1 0] [0 1] [0]
[bfs#1](x1, x2, x3) = [0 2] x1 + [0 2] x2 + [0]
[0 0] [0 0] [0]
[bfs#3](x1, x2, x3, x4) = [2 0] x1 + [0 2] x2 + [0
2] x3 + [0]
[0 0] [0 0] [0
0] [0]
[#0] = [0]
[0]
[#neg](x1) = [1 0] x1 + [1]
[0 1] [0]
[#s](x1) = [1 0] x1 + [0]
[0 1] [0]
[bfs#4^#](x1, x2, x3, x4, x5, x6, x7) = [1 5] x1 + [1 2] x2 + [2
1] x3 + [2 1] x4 + [0 2] x5 + [5]
[0 0] [0 0] [0
0] [0 0] [0 0] [0]
[bfs^#](x1, x2, x3) = [0 2] x1 + [1 2] x2 + [0
0] x3 + [3]
[1 0] [1 1] [1
0] [0]
[reverse^#](x1) = [1 0] x1 + [0]
[1 0] [1]
[dobfs^#](x1, x2) = [2 5] x1 + [3]
[0 1] [0]
[bfs2#1^#](x1, x2) = [2 7] x1 + [0 0] x2 + [4]
[0 0] [4 4] [1]
[bfs2^#](x1, x2) = [7 7] x1 + [7 7] x2 + [7]
[7 7] [7 7] [7]
[bfs#1^#](x1, x2, x3) = [0 2] x1 + [1 2] x2 + [3]
[0 0] [0 0] [0]
[bfs#2^#](x1, x2) = [1 2] x1 + [1]
[0 0] [0]
[bfs#3^#](x1, x2, x3, x4) = [2 0] x1 + [1 2] x2 + [0
2] x3 + [3]
[0 0] [0 0] [0
0] [0]
[c_1](x1) = [1 0] x1 + [0]
[0 0] [0]
[c_2](x1) = [1 1] x1 + [0]
[0 0] [0]
[c_9](x1) = [1 0] x1 + [0]
[0 0] [0]
[c_12](x1) = [1 2] x1 + [0]
[0 0] [0]
[c_13](x1, x2) = [1 0] x1 + [1 1] x2 + [0]
[0 0] [0 0] [4]
[c_14](x1) = [1 1] x1 + [1]
[0 0] [0]
[c_15](x1) = [1 1] x1 + [0]
[0 0] [0]
[c_16](x1, x2) = [1 0] x1 + [0]
[0 0] [0]
[c_17](x1) = [1 0] x1 + [0]
[0 0] [0]
[c_18](x1) = [1 1] x1 + [0]
[0 0] [0]
The order satisfies the following ordering constraints:
[#equal(@x, @y)] = [4]
[1]
>= [4]
[1]
= [#eq(@x, @y)]
[bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [0 2] @futurequeue + [0 2] @ts + [2 2] @t1 + [2 1] @t2 + [7]
[0 0] [0 0] [0 0] [0 0] [0]
> [1 1] @t1 + [1 1] @t2 + [6]
[0 0] [0 0] [0]
= [node(@y, @t1, @t2)]
[bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [0 2] @futurequeue + [0 2] @ts + [2 2] @t1 + [2 1] @t2 + [7]
[0 0] [0 0] [0 0] [0 0] [0]
> [0 2] @futurequeue + [0 2] @ts + [2 0] @t1 + [2 0] @t2 + [0]
[0 0] [0 0] [0 0] [0 0] [0]
= [bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)]
[#eq(leaf(), leaf())] = [4]
[1]
> [0]
[1]
= [#true()]
[#eq(leaf(), node(@y_1, @y_2, @y_3))] = [4]
[1]
> [2]
[1]
= [#false()]
[#eq(leaf(), nil())] = [4]
[1]
> [2]
[1]
= [#false()]
[#eq(leaf(), ::(@y_1, @y_2))] = [4]
[1]
> [2]
[1]
= [#false()]
[#eq(#pos(@x), #pos(@y))] = [4]
[1]
>= [4]
[1]
= [#eq(@x, @y)]
[#eq(#pos(@x), #0())] = [4]
[1]
> [2]
[1]
= [#false()]
[#eq(#pos(@x), #neg(@y))] = [4]
[1]
> [2]
[1]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), leaf())] = [4]
[1]
> [2]
[1]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3))] = [4]
[1]
> [2]
[1]
= [#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))]
[#eq(node(@x_1, @x_2, @x_3), nil())] = [4]
[1]
> [2]
[1]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2))] = [4]
[1]
> [2]
[1]
= [#false()]
[#eq(nil(), leaf())] = [4]
[1]
> [2]
[1]
= [#false()]
[#eq(nil(), node(@y_1, @y_2, @y_3))] = [4]
[1]
> [2]
[1]
= [#false()]
[#eq(nil(), nil())] = [4]
[1]
> [0]
[1]
= [#true()]
[#eq(nil(), ::(@y_1, @y_2))] = [4]
[1]
> [2]
[1]
= [#false()]
[#eq(::(@x_1, @x_2), leaf())] = [4]
[1]
> [2]
[1]
= [#false()]
[#eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3))] = [4]
[1]
> [2]
[1]
= [#false()]
[#eq(::(@x_1, @x_2), nil())] = [4]
[1]
> [2]
[1]
= [#false()]
[#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [4]
[1]
> [2]
[1]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(#0(), #pos(@y))] = [4]
[1]
> [2]
[1]
= [#false()]
[#eq(#0(), #0())] = [4]
[1]
> [0]
[1]
= [#true()]
[#eq(#0(), #neg(@y))] = [4]
[1]
> [2]
[1]
= [#false()]
[#eq(#0(), #s(@y))] = [4]
[1]
> [2]
[1]
= [#false()]
[#eq(#neg(@x), #pos(@y))] = [4]
[1]
> [2]
[1]
= [#false()]
[#eq(#neg(@x), #0())] = [4]
[1]
> [2]
[1]
= [#false()]
[#eq(#neg(@x), #neg(@y))] = [4]
[1]
>= [4]
[1]
= [#eq(@x, @y)]
[#eq(#s(@x), #0())] = [4]
[1]
> [2]
[1]
= [#false()]
[#eq(#s(@x), #s(@y))] = [4]
[1]
>= [4]
[1]
= [#eq(@x, @y)]
[reverse(@xs)] = [5 1] @xs + [0]
[0 1] [0]
>= [2 1] @xs + [0]
[0 1] [0]
= [appendreverse(@xs, nil())]
[appendreverse#1(nil(), @sofar)] = [2 0] @sofar + [0]
[0 1] [0]
>= [1 0] @sofar + [0]
[0 1] [0]
= [@sofar]
[appendreverse#1(::(@a, @as), @sofar)] = [2 0] @sofar + [1 2] @a + [2 1] @as + [8]
[0 1] [1 0] [0 1] [0]
>= [2 0] @sofar + [0 2] @a + [2 1] @as + [8]
[0 1] [1 0] [0 1] [0]
= [appendreverse(@as, ::(@a, @sofar))]
[appendreverse(@toreverse, @sofar)] = [2 1] @toreverse + [2 0] @sofar + [0]
[0 1] [0 1] [0]
>= [2 1] @toreverse + [2 0] @sofar + [0]
[0 1] [0 1] [0]
= [appendreverse#1(@toreverse, @sofar)]
[dobfs(@t, @x)] = [0 0] @x + [2 0] @t + [0]
[1 0] [0 0] [0]
>= [2 0] @t + [0]
[0 0] [0]
= [bfs(::(@t, nil()), nil(), @x)]
[bfs(@queue, @futurequeue, @x)] = [0 2] @queue + [0 2] @futurequeue + [0]
[0 0] [0 0] [0]
>= [0 2] @queue + [0 2] @futurequeue + [0]
[0 0] [0 0] [0]
= [bfs#1(@queue, @futurequeue, @x)]
[#and(#true(), #true())] = [2]
[1]
> [0]
[1]
= [#true()]
[#and(#true(), #false())] = [2]
[1]
>= [2]
[1]
= [#false()]
[#and(#false(), #true())] = [2]
[1]
>= [2]
[1]
= [#false()]
[#and(#false(), #false())] = [2]
[1]
>= [2]
[1]
= [#false()]
[bfs#2(nil(), @x)] = [0]
[0]
>= [0]
[0]
= [leaf()]
[bfs#2(::(@t, @ts), @x)] = [2 0] @t + [0 2] @ts + [0]
[0 0] [0 0] [0]
>= [2 0] @t + [0 2] @ts + [0]
[0 0] [0 0] [0]
= [bfs(reverse(::(@t, @ts)), nil(), @x)]
[bfs#1(nil(), @futurequeue, @x)] = [0 2] @futurequeue + [0]
[0 0] [0]
>= [0 2] @futurequeue + [0]
[0 0] [0]
= [bfs#2(@futurequeue, @x)]
[bfs#1(::(@t, @ts), @futurequeue, @x)] = [0 2] @futurequeue + [2 0] @t + [0 2] @ts + [0]
[0 0] [0 0] [0 0] [0]
>= [0 2] @futurequeue + [2 0] @t + [0 2] @ts + [0]
[0 0] [0 0] [0 0] [0]
= [bfs#3(@t, @futurequeue, @ts, @x)]
[bfs#3(leaf(), @futurequeue, @ts, @x)] = [0 2] @futurequeue + [0 2] @ts + [0]
[0 0] [0 0] [0]
>= [0 2] @futurequeue + [0 2] @ts + [0]
[0 0] [0 0] [0]
= [bfs(@ts, @futurequeue, @x)]
[bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [0 2] @futurequeue + [0 2] @ts + [2 2] @t1 + [2 2] @t2 + [12]
[0 0] [0 0] [0 0] [0 0] [0]
> [0 2] @futurequeue + [0 2] @ts + [2 2] @t1 + [2 1] @t2 + [7]
[0 0] [0 0] [0 0] [0 0] [0]
= [bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)]
[bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1 2] @futurequeue + [0 2] @ts + [2 1] @t1 + [2 1] @t2 + [12]
[0 0] [0 0] [0 0] [0 0] [0]
> [1 2] @futurequeue + [0 2] @ts + [2 1] @t1 + [2 1] @t2 + [11]
[0 0] [0 0] [0 0] [0 0] [0]
= [c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))]
[bfs^#(@queue, @futurequeue, @x)] = [0 0] @x + [0 2] @queue + [1 2] @futurequeue + [3]
[1 0] [1 0] [1 1] [0]
>= [0 2] @queue + [1 2] @futurequeue + [3]
[0 0] [0 0] [0]
= [c_2(bfs#1^#(@queue, @futurequeue, @x))]
[dobfs^#(@t, @x)] = [2 5] @t + [3]
[0 1] [0]
>= [2 0] @t + [3]
[0 0] [0]
= [c_9(bfs^#(::(@t, nil()), nil(), @x))]
[bfs2#1^#(@t', @x)] = [0 0] @x + [2 7] @t' + [4]
[4 4] [0 0] [1]
> [2 7] @t' + [3]
[0 0] [0]
= [c_12(dobfs^#(@t', @x))]
[bfs2^#(@t, @x)] = [7 7] @x + [7 7] @t + [7]
[7 7] [7 7] [7]
>= [7 0] @x + [6 6] @t + [7]
[0 0] [0 0] [4]
= [c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))]
[bfs#1^#(nil(), @futurequeue, @x)] = [1 2] @futurequeue + [3]
[0 0] [0]
> [1 2] @futurequeue + [2]
[0 0] [0]
= [c_14(bfs#2^#(@futurequeue, @x))]
[bfs#1^#(::(@t, @ts), @futurequeue, @x)] = [1 2] @futurequeue + [2 0] @t + [0 2] @ts + [3]
[0 0] [0 0] [0 0] [0]
>= [1 2] @futurequeue + [2 0] @t + [0 2] @ts + [3]
[0 0] [0 0] [0 0] [0]
= [c_15(bfs#3^#(@t, @futurequeue, @ts, @x))]
[bfs#2^#(::(@t, @ts), @x)] = [2 1] @t + [1 2] @ts + [5]
[0 0] [0 0] [0]
> [2 0] @t + [0 2] @ts + [3]
[0 0] [0 0] [0]
= [c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))]
[bfs#3^#(leaf(), @futurequeue, @ts, @x)] = [1 2] @futurequeue + [0 2] @ts + [3]
[0 0] [0 0] [0]
>= [1 2] @futurequeue + [0 2] @ts + [3]
[0 0] [0 0] [0]
= [c_17(bfs^#(@ts, @futurequeue, @x))]
[bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [1 2] @futurequeue + [0 2] @ts + [2 2] @t1 + [2 2] @t2 + [15]
[0 0] [0 0] [0 0] [0 0] [0]
> [1 2] @futurequeue + [0 2] @ts + [2 1] @t1 + [2 1] @t2 + [14]
[0 0] [0 0] [0 0] [0 0] [0]
= [c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y))]
We return to the main proof. Consider the set of all dependency
pairs
:
{ 1: bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x))
, 2: bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, 3: bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, 4: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, 5: dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, 6: bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, 7: bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, 8: bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, 9: bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x))
, 10: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y)) }
Processor 'matrix interpretation of dimension 2' induces the
complexity certificate YES(?,O(n^1)) on application of dependency
pairs {2,3,4,6,10}. These cover all (indirect) predecessors of
dependency pairs {2,3,4,5,6,7,10}, their number of application is
equally bounded. The dependency pairs are shifted into the weak
component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x)) }
Weak DPs:
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x))
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We use the processor 'matrix interpretation of dimension 2' to
orient following rules strictly.
DPs:
{ 2: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, 5: bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, 7: bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, 8: bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, 9: bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x))
, 10: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y)) }
Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(nil(), nil()) -> #true()
, #eq(#0(), #0()) -> #true()
, #and(#true(), #true()) -> #true()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) }
Sub-proof:
----------
The following argument positions are usable:
Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_9) = {1},
Uargs(c_12) = {1}, Uargs(c_13) = {1, 2}, Uargs(c_14) = {1},
Uargs(c_15) = {1}, Uargs(c_16) = {1}, Uargs(c_17) = {1},
Uargs(c_18) = {1}
TcT has computed the following constructor-based matrix
interpretation satisfying not(EDA) and not(IDA(1)).
[#equal](x1, x2) = [6]
[4]
[bfs#4](x1, x2, x3, x4, x5, x6, x7) = [0 0] x1 + [1 1] x2 + [1
1] x3 + [1 1] x4 + [0 1] x5 + [6]
[1 0] [0 1] [1
1] [1 1] [0 1] [1]
[#eq](x1, x2) = [4]
[4]
[reverse](x1) = [1 0] x1 + [0]
[0 1] [0]
[appendreverse#1](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
[0 1] [0 1] [0]
[appendreverse](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
[0 1] [0 1] [0]
[#true] = [0]
[0]
[leaf] = [0]
[0]
[dobfs](x1, x2) = [1 1] x1 + [0]
[1 1] [0]
[#pos](x1) = [1 0] x1 + [0]
[0 1] [0]
[node](x1, x2, x3) = [1 1] x2 + [1 1] x3 + [6]
[0 0] [0 0] [1]
[bfs](x1, x2, x3) = [0 1] x1 + [1 1] x2 + [0]
[0 1] [0 1] [0]
[#and](x1, x2) = [4]
[3]
[nil] = [0]
[0]
[bfs#2](x1, x2) = [1 1] x1 + [0]
[0 1] [0]
[#false] = [4]
[3]
[::](x1, x2) = [0 0] x1 + [1 0] x2 + [1]
[1 1] [0 1] [0]
[bfs#1](x1, x2, x3) = [0 1] x1 + [1 1] x2 + [0]
[0 1] [0 1] [0]
[bfs#3](x1, x2, x3, x4) = [1 0] x1 + [1 1] x2 + [0
1] x3 + [0]
[1 1] [0 1] [0
1] [0]
[#0] = [0]
[0]
[#neg](x1) = [1 0] x1 + [0]
[0 1] [0]
[#s](x1) = [1 0] x1 + [0]
[0 1] [0]
[bfs#4^#](x1, x2, x3, x4, x5, x6, x7) = [1 1] x1 + [4 2] x2 + [2
2] x3 + [2 2] x4 + [3 2] x5 + [2]
[0 0] [0 0] [4
4] [4 5] [0 4] [0]
[bfs^#](x1, x2, x3) = [3 2] x1 + [4 2] x2 + [0]
[0 0] [0 0] [0]
[reverse^#](x1) = [1 0] x1 + [2]
[1 0] [0]
[dobfs^#](x1, x2) = [2 2] x1 + [2 0] x2 + [3]
[1 0] [4 4] [0]
[bfs2#1^#](x1, x2) = [2 3] x1 + [2 0] x2 + [3]
[1 0] [4 0] [0]
[bfs2^#](x1, x2) = [7 7] x1 + [7 7] x2 + [7]
[7 7] [7 7] [7]
[bfs#1^#](x1, x2, x3) = [3 2] x1 + [4 2] x2 + [0]
[0 0] [0 0] [1]
[bfs#2^#](x1, x2) = [4 2] x1 + [0]
[0 0] [1]
[bfs#3^#](x1, x2, x3, x4) = [2 1] x1 + [4 2] x2 + [3
2] x3 + [0 0] x4 + [1]
[1 2] [0 0] [0
0] [1 0] [0]
[c_1](x1) = [1 0] x1 + [0]
[0 0] [0]
[c_2](x1) = [1 0] x1 + [0]
[0 0] [0]
[c_9](x1) = [1 0] x1 + [0]
[0 0] [0]
[c_12](x1) = [1 0] x1 + [0]
[0 0] [0]
[c_13](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
[0 0] [0 0] [4]
[c_14](x1) = [1 0] x1 + [0]
[0 0] [0]
[c_15](x1) = [1 0] x1 + [1]
[0 0] [0]
[c_16](x1, x2) = [1 1] x1 + [0]
[0 0] [0]
[c_17](x1) = [1 0] x1 + [0]
[0 0] [0]
[c_18](x1) = [1 0] x1 + [0]
[0 0] [0]
The order satisfies the following ordering constraints:
[#equal(@x, @y)] = [6]
[4]
> [4]
[4]
= [#eq(@x, @y)]
[bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1 1] @futurequeue + [0 1] @ts + [1 1] @t1 + [1 1] @t2 + [6]
[0 1] [0 1] [1 1] [1 1] [1]
>= [1 1] @t1 + [1 1] @t2 + [6]
[0 0] [0 0] [1]
= [node(@y, @t1, @t2)]
[bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1 1] @futurequeue + [0 1] @ts + [1 1] @t1 + [1 1] @t2 + [6]
[0 1] [0 1] [1 1] [1 1] [5]
> [1 1] @futurequeue + [0 1] @ts + [1 1] @t1 + [1 1] @t2 + [2]
[0 1] [0 1] [1 1] [1 1] [0]
= [bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)]
[#eq(leaf(), leaf())] = [4]
[4]
> [0]
[0]
= [#true()]
[#eq(leaf(), node(@y_1, @y_2, @y_3))] = [4]
[4]
>= [4]
[3]
= [#false()]
[#eq(leaf(), nil())] = [4]
[4]
>= [4]
[3]
= [#false()]
[#eq(leaf(), ::(@y_1, @y_2))] = [4]
[4]
>= [4]
[3]
= [#false()]
[#eq(#pos(@x), #pos(@y))] = [4]
[4]
>= [4]
[4]
= [#eq(@x, @y)]
[#eq(#pos(@x), #0())] = [4]
[4]
>= [4]
[3]
= [#false()]
[#eq(#pos(@x), #neg(@y))] = [4]
[4]
>= [4]
[3]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), leaf())] = [4]
[4]
>= [4]
[3]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3))] = [4]
[4]
>= [4]
[3]
= [#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))]
[#eq(node(@x_1, @x_2, @x_3), nil())] = [4]
[4]
>= [4]
[3]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2))] = [4]
[4]
>= [4]
[3]
= [#false()]
[#eq(nil(), leaf())] = [4]
[4]
>= [4]
[3]
= [#false()]
[#eq(nil(), node(@y_1, @y_2, @y_3))] = [4]
[4]
>= [4]
[3]
= [#false()]
[#eq(nil(), nil())] = [4]
[4]
> [0]
[0]
= [#true()]
[#eq(nil(), ::(@y_1, @y_2))] = [4]
[4]
>= [4]
[3]
= [#false()]
[#eq(::(@x_1, @x_2), leaf())] = [4]
[4]
>= [4]
[3]
= [#false()]
[#eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3))] = [4]
[4]
>= [4]
[3]
= [#false()]
[#eq(::(@x_1, @x_2), nil())] = [4]
[4]
>= [4]
[3]
= [#false()]
[#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [4]
[4]
>= [4]
[3]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(#0(), #pos(@y))] = [4]
[4]
>= [4]
[3]
= [#false()]
[#eq(#0(), #0())] = [4]
[4]
> [0]
[0]
= [#true()]
[#eq(#0(), #neg(@y))] = [4]
[4]
>= [4]
[3]
= [#false()]
[#eq(#0(), #s(@y))] = [4]
[4]
>= [4]
[3]
= [#false()]
[#eq(#neg(@x), #pos(@y))] = [4]
[4]
>= [4]
[3]
= [#false()]
[#eq(#neg(@x), #0())] = [4]
[4]
>= [4]
[3]
= [#false()]
[#eq(#neg(@x), #neg(@y))] = [4]
[4]
>= [4]
[4]
= [#eq(@x, @y)]
[#eq(#s(@x), #0())] = [4]
[4]
>= [4]
[3]
= [#false()]
[#eq(#s(@x), #s(@y))] = [4]
[4]
>= [4]
[4]
= [#eq(@x, @y)]
[reverse(@xs)] = [1 0] @xs + [0]
[0 1] [0]
>= [1 0] @xs + [0]
[0 1] [0]
= [appendreverse(@xs, nil())]
[appendreverse#1(nil(), @sofar)] = [1 0] @sofar + [0]
[0 1] [0]
>= [1 0] @sofar + [0]
[0 1] [0]
= [@sofar]
[appendreverse#1(::(@a, @as), @sofar)] = [1 0] @sofar + [0 0] @a + [1 0] @as + [1]
[0 1] [1 1] [0 1] [0]
>= [1 0] @sofar + [0 0] @a + [1 0] @as + [1]
[0 1] [1 1] [0 1] [0]
= [appendreverse(@as, ::(@a, @sofar))]
[appendreverse(@toreverse, @sofar)] = [1 0] @toreverse + [1 0] @sofar + [0]
[0 1] [0 1] [0]
>= [1 0] @toreverse + [1 0] @sofar + [0]
[0 1] [0 1] [0]
= [appendreverse#1(@toreverse, @sofar)]
[dobfs(@t, @x)] = [1 1] @t + [0]
[1 1] [0]
>= [1 1] @t + [0]
[1 1] [0]
= [bfs(::(@t, nil()), nil(), @x)]
[bfs(@queue, @futurequeue, @x)] = [0 1] @queue + [1 1] @futurequeue + [0]
[0 1] [0 1] [0]
>= [0 1] @queue + [1 1] @futurequeue + [0]
[0 1] [0 1] [0]
= [bfs#1(@queue, @futurequeue, @x)]
[#and(#true(), #true())] = [4]
[3]
> [0]
[0]
= [#true()]
[#and(#true(), #false())] = [4]
[3]
>= [4]
[3]
= [#false()]
[#and(#false(), #true())] = [4]
[3]
>= [4]
[3]
= [#false()]
[#and(#false(), #false())] = [4]
[3]
>= [4]
[3]
= [#false()]
[bfs#2(nil(), @x)] = [0]
[0]
>= [0]
[0]
= [leaf()]
[bfs#2(::(@t, @ts), @x)] = [1 1] @t + [1 1] @ts + [1]
[1 1] [0 1] [0]
> [1 1] @t + [0 1] @ts + [0]
[1 1] [0 1] [0]
= [bfs(reverse(::(@t, @ts)), nil(), @x)]
[bfs#1(nil(), @futurequeue, @x)] = [1 1] @futurequeue + [0]
[0 1] [0]
>= [1 1] @futurequeue + [0]
[0 1] [0]
= [bfs#2(@futurequeue, @x)]
[bfs#1(::(@t, @ts), @futurequeue, @x)] = [1 1] @futurequeue + [1 1] @t + [0 1] @ts + [0]
[0 1] [1 1] [0 1] [0]
>= [1 1] @futurequeue + [1 0] @t + [0 1] @ts + [0]
[0 1] [1 1] [0 1] [0]
= [bfs#3(@t, @futurequeue, @ts, @x)]
[bfs#3(leaf(), @futurequeue, @ts, @x)] = [1 1] @futurequeue + [0 1] @ts + [0]
[0 1] [0 1] [0]
>= [1 1] @futurequeue + [0 1] @ts + [0]
[0 1] [0 1] [0]
= [bfs(@ts, @futurequeue, @x)]
[bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [1 1] @futurequeue + [0 1] @ts + [1 1] @t1 + [1 1] @t2 + [6]
[0 1] [0 1] [1 1] [1 1] [7]
>= [1 1] @futurequeue + [0 1] @ts + [1 1] @t1 + [1 1] @t2 + [6]
[0 1] [0 1] [1 1] [1 1] [7]
= [bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)]
[bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [4 2] @futurequeue + [3 2] @ts + [2 2] @t1 + [2 2] @t2 + [9]
[0 0] [0 4] [4 4] [4 5] [0]
> [4 2] @futurequeue + [3 2] @ts + [2 2] @t1 + [2 2] @t2 + [8]
[0 0] [0 0] [0 0] [0 0] [0]
= [c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))]
[bfs^#(@queue, @futurequeue, @x)] = [3 2] @queue + [4 2] @futurequeue + [0]
[0 0] [0 0] [0]
>= [3 2] @queue + [4 2] @futurequeue + [0]
[0 0] [0 0] [0]
= [c_2(bfs#1^#(@queue, @futurequeue, @x))]
[dobfs^#(@t, @x)] = [2 0] @x + [2 2] @t + [3]
[4 4] [1 0] [0]
>= [2 2] @t + [3]
[0 0] [0]
= [c_9(bfs^#(::(@t, nil()), nil(), @x))]
[bfs2#1^#(@t', @x)] = [2 0] @x + [2 3] @t' + [3]
[4 0] [1 0] [0]
>= [2 0] @x + [2 2] @t' + [3]
[0 0] [0 0] [0]
= [c_12(dobfs^#(@t', @x))]
[bfs2^#(@t, @x)] = [7 7] @x + [7 7] @t + [7]
[7 7] [7 7] [7]
> [4 0] @x + [7 7] @t + [6]
[0 0] [0 0] [4]
= [c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))]
[bfs#1^#(nil(), @futurequeue, @x)] = [4 2] @futurequeue + [0]
[0 0] [1]
>= [4 2] @futurequeue + [0]
[0 0] [0]
= [c_14(bfs#2^#(@futurequeue, @x))]
[bfs#1^#(::(@t, @ts), @futurequeue, @x)] = [4 2] @futurequeue + [2 2] @t + [3 2] @ts + [3]
[0 0] [0 0] [0 0] [1]
> [4 2] @futurequeue + [2 1] @t + [3 2] @ts + [2]
[0 0] [0 0] [0 0] [0]
= [c_15(bfs#3^#(@t, @futurequeue, @ts, @x))]
[bfs#2^#(::(@t, @ts), @x)] = [2 2] @t + [4 2] @ts + [4]
[0 0] [0 0] [1]
> [2 2] @t + [3 2] @ts + [3]
[0 0] [0 0] [0]
= [c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))]
[bfs#3^#(leaf(), @futurequeue, @ts, @x)] = [0 0] @x + [4 2] @futurequeue + [3 2] @ts + [1]
[1 0] [0 0] [0 0] [0]
> [4 2] @futurequeue + [3 2] @ts + [0]
[0 0] [0 0] [0]
= [c_17(bfs^#(@ts, @futurequeue, @x))]
[bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [0 0] @x + [4 2] @futurequeue + [3 2] @ts + [2 2] @t1 + [2
2] @t2 + [14]
[1 0] [0 0] [0 0] [1 1] [1
1] [8]
> [4 2] @futurequeue + [3 2] @ts + [2 2] @t1 + [2 2] @t2 + [12]
[0 0] [0 0] [0 0] [0 0] [0]
= [c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y))]
We return to the main proof. Consider the set of all dependency
pairs
:
{ 1: bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x))
, 2: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, 3: dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, 4: bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, 5: bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, 6: bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, 7: bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, 8: bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, 9: bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x))
, 10: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y)) }
Processor 'matrix interpretation of dimension 2' induces the
complexity certificate YES(?,O(n^1)) on application of dependency
pairs {2,5,7,8,9,10}. These cover all (indirect) predecessors of
dependency pairs {1,2,3,4,5,6,7,8,9,10}, their number of
application is equally bounded. The dependency pairs are shifted
into the weak component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Weak DPs:
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x))
, dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x))
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
The following weak DPs constitute a sub-graph of the DG that is
closed under successors. The DPs are removed.
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x))
, dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x))
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
No rule is usable, rules are removed from the input problem.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Rules: Empty
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
Empty rules are trivially bounded
We return to the main proof.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ reverse^#(@xs) -> c_3(appendreverse^#(@xs, nil()))
, appendreverse^#(@toreverse, @sofar) ->
c_4(appendreverse#1^#(@toreverse, @sofar))
, appendreverse#1^#(::(@a, @as), @sofar) ->
c_5(appendreverse^#(@as, ::(@a, @sofar))) }
Weak DPs:
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, bfs^#(@queue, @futurequeue, @x) ->
bfs#1^#(@queue, @futurequeue, @x)
, dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x)
, bfs2#1^#(@t', @x) -> dobfs^#(@t', @x)
, bfs2^#(@t, @x) -> dobfs^#(@t, @x)
, bfs2^#(@t, @x) -> bfs2#1^#(dobfs(@t, @x), @x)
, bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x)
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
bfs#3^#(@t, @futurequeue, @ts, @x)
, bfs#2^#(::(@t, @ts), @x) ->
bfs^#(reverse(::(@t, @ts)), nil(), @x)
, bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
bfs^#(@ts, @futurequeue, @x)
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We use the processor 'matrix interpretation of dimension 1' to
orient following rules strictly.
DPs:
{ 2: appendreverse^#(@toreverse, @sofar) ->
c_4(appendreverse#1^#(@toreverse, @sofar))
, 4: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, 6: dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x)
, 8: bfs2^#(@t, @x) -> dobfs^#(@t, @x)
, 13: bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts))
, 14: bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
bfs^#(@ts, @futurequeue, @x) }
Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x) }
Sub-proof:
----------
The following argument positions are usable:
Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}
TcT has computed the following constructor-based matrix
interpretation satisfying not(EDA).
[#equal](x1, x2) = [4]
[bfs#4](x1, x2, x3, x4, x5, x6, x7) = [1] x1 + [1] x2 + [1] x3 + [1] x4 + [1] x5 + [4]
[#eq](x1, x2) = [3]
[reverse](x1) = [1] x1 + [0]
[appendreverse#1](x1, x2) = [1] x1 + [1] x2 + [0]
[appendreverse](x1, x2) = [1] x1 + [1] x2 + [0]
[#true] = [3]
[leaf] = [0]
[dobfs](x1, x2) = [1] x1 + [1]
[#pos](x1) = [1] x1 + [0]
[node](x1, x2, x3) = [1] x2 + [1] x3 + [7]
[bfs](x1, x2, x3) = [1] x1 + [1] x2 + [0]
[#and](x1, x2) = [1] x2 + [0]
[nil] = [0]
[bfs#2](x1, x2) = [1] x1 + [0]
[#false] = [3]
[::](x1, x2) = [1] x1 + [1] x2 + [1]
[bfs#1](x1, x2, x3) = [1] x1 + [1] x2 + [0]
[bfs#3](x1, x2, x3, x4) = [1] x1 + [1] x2 + [1] x3 + [1]
[#0] = [2]
[#neg](x1) = [1] x1 + [0]
[#s](x1) = [1] x1 + [2]
[bfs#4^#](x1, x2, x3, x4, x5, x6, x7) = [2] x1 + [1] x2 + [1] x3 + [1] x4 + [1] x5 + [2]
[bfs^#](x1, x2, x3) = [1] x1 + [1] x2 + [2]
[reverse^#](x1) = [1] x1 + [1]
[appendreverse^#](x1, x2) = [1] x1 + [1]
[appendreverse#1^#](x1, x2) = [1] x1 + [0]
[dobfs^#](x1, x2) = [1] x1 + [6]
[bfs2#1^#](x1, x2) = [1] x1 + [7] x2 + [6]
[bfs2^#](x1, x2) = [7] x1 + [7] x2 + [7]
[bfs#1^#](x1, x2, x3) = [1] x1 + [1] x2 + [2]
[bfs#2^#](x1, x2) = [1] x1 + [2]
[bfs#3^#](x1, x2, x3, x4) = [1] x1 + [1] x2 + [1] x3 + [3]
[c_3](x1) = [1] x1 + [0]
[c_4](x1) = [1] x1 + [0]
[c_5](x1) = [1] x1 + [0]
The order satisfies the following ordering constraints:
[#equal(@x, @y)] = [4]
> [3]
= [#eq(@x, @y)]
[bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [7]
>= [1] @t1 + [1] @t2 + [7]
= [node(@y, @t1, @t2)]
[bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [7]
> [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [2]
= [bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)]
[#eq(leaf(), leaf())] = [3]
>= [3]
= [#true()]
[#eq(leaf(), node(@y_1, @y_2, @y_3))] = [3]
>= [3]
= [#false()]
[#eq(leaf(), nil())] = [3]
>= [3]
= [#false()]
[#eq(leaf(), ::(@y_1, @y_2))] = [3]
>= [3]
= [#false()]
[#eq(#pos(@x), #pos(@y))] = [3]
>= [3]
= [#eq(@x, @y)]
[#eq(#pos(@x), #0())] = [3]
>= [3]
= [#false()]
[#eq(#pos(@x), #neg(@y))] = [3]
>= [3]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), leaf())] = [3]
>= [3]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3))] = [3]
>= [3]
= [#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))]
[#eq(node(@x_1, @x_2, @x_3), nil())] = [3]
>= [3]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2))] = [3]
>= [3]
= [#false()]
[#eq(nil(), leaf())] = [3]
>= [3]
= [#false()]
[#eq(nil(), node(@y_1, @y_2, @y_3))] = [3]
>= [3]
= [#false()]
[#eq(nil(), nil())] = [3]
>= [3]
= [#true()]
[#eq(nil(), ::(@y_1, @y_2))] = [3]
>= [3]
= [#false()]
[#eq(::(@x_1, @x_2), leaf())] = [3]
>= [3]
= [#false()]
[#eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3))] = [3]
>= [3]
= [#false()]
[#eq(::(@x_1, @x_2), nil())] = [3]
>= [3]
= [#false()]
[#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [3]
>= [3]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(#0(), #pos(@y))] = [3]
>= [3]
= [#false()]
[#eq(#0(), #0())] = [3]
>= [3]
= [#true()]
[#eq(#0(), #neg(@y))] = [3]
>= [3]
= [#false()]
[#eq(#0(), #s(@y))] = [3]
>= [3]
= [#false()]
[#eq(#neg(@x), #pos(@y))] = [3]
>= [3]
= [#false()]
[#eq(#neg(@x), #0())] = [3]
>= [3]
= [#false()]
[#eq(#neg(@x), #neg(@y))] = [3]
>= [3]
= [#eq(@x, @y)]
[#eq(#s(@x), #0())] = [3]
>= [3]
= [#false()]
[#eq(#s(@x), #s(@y))] = [3]
>= [3]
= [#eq(@x, @y)]
[reverse(@xs)] = [1] @xs + [0]
>= [1] @xs + [0]
= [appendreverse(@xs, nil())]
[appendreverse#1(nil(), @sofar)] = [1] @sofar + [0]
>= [1] @sofar + [0]
= [@sofar]
[appendreverse#1(::(@a, @as), @sofar)] = [1] @sofar + [1] @a + [1] @as + [1]
>= [1] @sofar + [1] @a + [1] @as + [1]
= [appendreverse(@as, ::(@a, @sofar))]
[appendreverse(@toreverse, @sofar)] = [1] @toreverse + [1] @sofar + [0]
>= [1] @toreverse + [1] @sofar + [0]
= [appendreverse#1(@toreverse, @sofar)]
[dobfs(@t, @x)] = [1] @t + [1]
>= [1] @t + [1]
= [bfs(::(@t, nil()), nil(), @x)]
[bfs(@queue, @futurequeue, @x)] = [1] @queue + [1] @futurequeue + [0]
>= [1] @queue + [1] @futurequeue + [0]
= [bfs#1(@queue, @futurequeue, @x)]
[#and(#true(), #true())] = [3]
>= [3]
= [#true()]
[#and(#true(), #false())] = [3]
>= [3]
= [#false()]
[#and(#false(), #true())] = [3]
>= [3]
= [#false()]
[#and(#false(), #false())] = [3]
>= [3]
= [#false()]
[bfs#2(nil(), @x)] = [0]
>= [0]
= [leaf()]
[bfs#2(::(@t, @ts), @x)] = [1] @t + [1] @ts + [1]
>= [1] @t + [1] @ts + [1]
= [bfs(reverse(::(@t, @ts)), nil(), @x)]
[bfs#1(nil(), @futurequeue, @x)] = [1] @futurequeue + [0]
>= [1] @futurequeue + [0]
= [bfs#2(@futurequeue, @x)]
[bfs#1(::(@t, @ts), @futurequeue, @x)] = [1] @futurequeue + [1] @t + [1] @ts + [1]
>= [1] @futurequeue + [1] @t + [1] @ts + [1]
= [bfs#3(@t, @futurequeue, @ts, @x)]
[bfs#3(leaf(), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @ts + [1]
> [1] @futurequeue + [1] @ts + [0]
= [bfs(@ts, @futurequeue, @x)]
[bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [8]
>= [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [8]
= [bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)]
[bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [8]
> [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [4]
= [bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)]
[bfs^#(@queue, @futurequeue, @x)] = [1] @queue + [1] @futurequeue + [2]
>= [1] @queue + [1] @futurequeue + [2]
= [bfs#1^#(@queue, @futurequeue, @x)]
[reverse^#(@xs)] = [1] @xs + [1]
>= [1] @xs + [1]
= [c_3(appendreverse^#(@xs, nil()))]
[appendreverse^#(@toreverse, @sofar)] = [1] @toreverse + [1]
> [1] @toreverse + [0]
= [c_4(appendreverse#1^#(@toreverse, @sofar))]
[appendreverse#1^#(::(@a, @as), @sofar)] = [1] @a + [1] @as + [1]
>= [1] @as + [1]
= [c_5(appendreverse^#(@as, ::(@a, @sofar)))]
[dobfs^#(@t, @x)] = [1] @t + [6]
> [1] @t + [3]
= [bfs^#(::(@t, nil()), nil(), @x)]
[bfs2#1^#(@t', @x)] = [7] @x + [1] @t' + [6]
>= [1] @t' + [6]
= [dobfs^#(@t', @x)]
[bfs2^#(@t, @x)] = [7] @x + [7] @t + [7]
> [1] @t + [6]
= [dobfs^#(@t, @x)]
[bfs2^#(@t, @x)] = [7] @x + [7] @t + [7]
>= [7] @x + [1] @t + [7]
= [bfs2#1^#(dobfs(@t, @x), @x)]
[bfs#1^#(nil(), @futurequeue, @x)] = [1] @futurequeue + [2]
>= [1] @futurequeue + [2]
= [bfs#2^#(@futurequeue, @x)]
[bfs#1^#(::(@t, @ts), @futurequeue, @x)] = [1] @futurequeue + [1] @t + [1] @ts + [3]
>= [1] @futurequeue + [1] @t + [1] @ts + [3]
= [bfs#3^#(@t, @futurequeue, @ts, @x)]
[bfs#2^#(::(@t, @ts), @x)] = [1] @t + [1] @ts + [3]
>= [1] @t + [1] @ts + [3]
= [bfs^#(reverse(::(@t, @ts)), nil(), @x)]
[bfs#2^#(::(@t, @ts), @x)] = [1] @t + [1] @ts + [3]
> [1] @t + [1] @ts + [2]
= [reverse^#(::(@t, @ts))]
[bfs#3^#(leaf(), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @ts + [3]
> [1] @futurequeue + [1] @ts + [2]
= [bfs^#(@ts, @futurequeue, @x)]
[bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [10]
>= [1] @futurequeue + [1] @ts + [1] @t1 + [1] @t2 + [10]
= [bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)]
We return to the main proof. Consider the set of all dependency
pairs
:
{ 1: reverse^#(@xs) -> c_3(appendreverse^#(@xs, nil()))
, 2: appendreverse^#(@toreverse, @sofar) ->
c_4(appendreverse#1^#(@toreverse, @sofar))
, 3: appendreverse#1^#(::(@a, @as), @sofar) ->
c_5(appendreverse^#(@as, ::(@a, @sofar)))
, 4: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, 5: bfs^#(@queue, @futurequeue, @x) ->
bfs#1^#(@queue, @futurequeue, @x)
, 6: dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x)
, 7: bfs2#1^#(@t', @x) -> dobfs^#(@t', @x)
, 8: bfs2^#(@t, @x) -> dobfs^#(@t, @x)
, 9: bfs2^#(@t, @x) -> bfs2#1^#(dobfs(@t, @x), @x)
, 10: bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x)
, 11: bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
bfs#3^#(@t, @futurequeue, @ts, @x)
, 12: bfs#2^#(::(@t, @ts), @x) ->
bfs^#(reverse(::(@t, @ts)), nil(), @x)
, 13: bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts))
, 14: bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
bfs^#(@ts, @futurequeue, @x)
, 15: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
Processor 'matrix interpretation of dimension 1' induces the
complexity certificate YES(?,O(n^1)) on application of dependency
pairs {2,4,6,8,13,14}. These cover all (indirect) predecessors of
dependency pairs {1,2,3,4,6,7,8,9,13,14}, their number of
application is equally bounded. The dependency pairs are shifted
into the weak component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Weak DPs:
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, bfs^#(@queue, @futurequeue, @x) ->
bfs#1^#(@queue, @futurequeue, @x)
, reverse^#(@xs) -> c_3(appendreverse^#(@xs, nil()))
, appendreverse^#(@toreverse, @sofar) ->
c_4(appendreverse#1^#(@toreverse, @sofar))
, appendreverse#1^#(::(@a, @as), @sofar) ->
c_5(appendreverse^#(@as, ::(@a, @sofar)))
, dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x)
, bfs2#1^#(@t', @x) -> dobfs^#(@t', @x)
, bfs2^#(@t, @x) -> dobfs^#(@t, @x)
, bfs2^#(@t, @x) -> bfs2#1^#(dobfs(@t, @x), @x)
, bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x)
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
bfs#3^#(@t, @futurequeue, @ts, @x)
, bfs#2^#(::(@t, @ts), @x) ->
bfs^#(reverse(::(@t, @ts)), nil(), @x)
, bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
bfs^#(@ts, @futurequeue, @x)
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
The following weak DPs constitute a sub-graph of the DG that is
closed under successors. The DPs are removed.
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, bfs^#(@queue, @futurequeue, @x) ->
bfs#1^#(@queue, @futurequeue, @x)
, reverse^#(@xs) -> c_3(appendreverse^#(@xs, nil()))
, appendreverse^#(@toreverse, @sofar) ->
c_4(appendreverse#1^#(@toreverse, @sofar))
, appendreverse#1^#(::(@a, @as), @sofar) ->
c_5(appendreverse^#(@as, ::(@a, @sofar)))
, dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x)
, bfs2#1^#(@t', @x) -> dobfs^#(@t', @x)
, bfs2^#(@t, @x) -> dobfs^#(@t, @x)
, bfs2^#(@t, @x) -> bfs2#1^#(dobfs(@t, @x), @x)
, bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x)
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
bfs#3^#(@t, @futurequeue, @ts, @x)
, bfs#2^#(::(@t, @ts), @x) ->
bfs^#(reverse(::(@t, @ts)), nil(), @x)
, bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
bfs^#(@ts, @futurequeue, @x)
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
No rule is usable, rules are removed from the input problem.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Rules: Empty
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
Empty rules are trivially bounded
S) We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ dfs#1^#(::(@t, @ts), @x) -> c_6(dfs#2^#(@t, @t, @ts, @x))
, dfs#2^#(leaf(), @t, @ts, @x) -> c_7(dfs^#(@ts, @x))
, dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_8(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
, dfs^#(@queue, @x) -> c_11(dfs#1^#(@queue, @x))
, dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_19(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
Weak DPs:
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x))
, reverse^#(@xs) -> c_3(appendreverse^#(@xs, nil()))
, appendreverse^#(@toreverse, @sofar) ->
c_4(appendreverse#1^#(@toreverse, @sofar))
, appendreverse#1^#(::(@a, @as), @sofar) ->
c_5(appendreverse^#(@as, ::(@a, @sofar)))
, dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x))
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
The following weak DPs constitute a sub-graph of the DG that is
closed under successors. The DPs are removed.
{ bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
c_1(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
, bfs^#(@queue, @futurequeue, @x) ->
c_2(bfs#1^#(@queue, @futurequeue, @x))
, reverse^#(@xs) -> c_3(appendreverse^#(@xs, nil()))
, appendreverse^#(@toreverse, @sofar) ->
c_4(appendreverse#1^#(@toreverse, @sofar))
, appendreverse#1^#(::(@a, @as), @sofar) ->
c_5(appendreverse^#(@as, ::(@a, @sofar)))
, dobfs^#(@t, @x) -> c_9(bfs^#(::(@t, nil()), nil(), @x))
, bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
, bfs2^#(@t, @x) ->
c_13(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
, bfs#1^#(nil(), @futurequeue, @x) ->
c_14(bfs#2^#(@futurequeue, @x))
, bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
c_15(bfs#3^#(@t, @futurequeue, @ts, @x))
, bfs#2^#(::(@t, @ts), @x) ->
c_16(bfs^#(reverse(::(@t, @ts)), nil(), @x),
reverse^#(::(@t, @ts)))
, bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
c_17(bfs^#(@ts, @futurequeue, @x))
, bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
c_18(bfs#4^#(#equal(@x, @y),
@futurequeue,
@t1,
@t2,
@ts,
@x,
@y)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ dfs#1^#(::(@t, @ts), @x) -> c_6(dfs#2^#(@t, @t, @ts, @x))
, dfs#2^#(leaf(), @t, @ts, @x) -> c_7(dfs^#(@ts, @x))
, dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_8(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
, dfs^#(@queue, @x) -> c_11(dfs#1^#(@queue, @x))
, dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_19(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
node(@y, @t1, @t2)
, bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, reverse(@xs) -> appendreverse(@xs, nil())
, appendreverse#1(nil(), @sofar) -> @sofar
, appendreverse#1(::(@a, @as), @sofar) ->
appendreverse(@as, ::(@a, @sofar))
, appendreverse(@toreverse, @sofar) ->
appendreverse#1(@toreverse, @sofar)
, dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
, bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false()
, bfs#2(nil(), @x) -> leaf()
, bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
, bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
, bfs#1(::(@t, @ts), @futurequeue, @x) ->
bfs#3(@t, @futurequeue, @ts, @x)
, bfs#3(leaf(), @futurequeue, @ts, @x) ->
bfs(@ts, @futurequeue, @x)
, bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We replace rewrite rules by usable rules:
Weak Usable Rules:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false() }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ dfs#1^#(::(@t, @ts), @x) -> c_6(dfs#2^#(@t, @t, @ts, @x))
, dfs#2^#(leaf(), @t, @ts, @x) -> c_7(dfs^#(@ts, @x))
, dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_8(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
, dfs^#(@queue, @x) -> c_11(dfs#1^#(@queue, @x))
, dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_19(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We use the processor 'matrix interpretation of dimension 1' to
orient following rules strictly.
DPs:
{ 2: dfs#2^#(leaf(), @t, @ts, @x) -> c_7(dfs^#(@ts, @x)) }
Sub-proof:
----------
The following argument positions are usable:
Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1},
Uargs(c_11) = {1}, Uargs(c_19) = {1}
TcT has computed the following constructor-based matrix
interpretation satisfying not(EDA).
[#equal](x1, x2) = [0]
[#eq](x1, x2) = [0]
[#true] = [0]
[leaf] = [2]
[#pos](x1) = [1] x1 + [0]
[node](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
[#and](x1, x2) = [0]
[nil] = [0]
[#false] = [0]
[::](x1, x2) = [1] x1 + [1] x2 + [0]
[#0] = [1]
[#neg](x1) = [1] x1 + [5]
[#s](x1) = [1] x1 + [0]
[dfs#1^#](x1, x2) = [4] x1 + [5]
[dfs#2^#](x1, x2, x3, x4) = [4] x1 + [4] x3 + [5]
[dfs^#](x1, x2) = [4] x1 + [5]
[dfs#3^#](x1, x2, x3, x4, x5, x6) = [4] x3 + [4] x4 + [4] x5 + [5]
[c_6](x1) = [1] x1 + [0]
[c_7](x1) = [1] x1 + [0]
[c_8](x1) = [1] x1 + [0]
[c_11](x1) = [1] x1 + [0]
[c_19](x1) = [1] x1 + [0]
The order satisfies the following ordering constraints:
[#equal(@x, @y)] = [0]
>= [0]
= [#eq(@x, @y)]
[#eq(leaf(), leaf())] = [0]
>= [0]
= [#true()]
[#eq(leaf(), node(@y_1, @y_2, @y_3))] = [0]
>= [0]
= [#false()]
[#eq(leaf(), nil())] = [0]
>= [0]
= [#false()]
[#eq(leaf(), ::(@y_1, @y_2))] = [0]
>= [0]
= [#false()]
[#eq(#pos(@x), #pos(@y))] = [0]
>= [0]
= [#eq(@x, @y)]
[#eq(#pos(@x), #0())] = [0]
>= [0]
= [#false()]
[#eq(#pos(@x), #neg(@y))] = [0]
>= [0]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), leaf())] = [0]
>= [0]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3))] = [0]
>= [0]
= [#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))]
[#eq(node(@x_1, @x_2, @x_3), nil())] = [0]
>= [0]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2))] = [0]
>= [0]
= [#false()]
[#eq(nil(), leaf())] = [0]
>= [0]
= [#false()]
[#eq(nil(), node(@y_1, @y_2, @y_3))] = [0]
>= [0]
= [#false()]
[#eq(nil(), nil())] = [0]
>= [0]
= [#true()]
[#eq(nil(), ::(@y_1, @y_2))] = [0]
>= [0]
= [#false()]
[#eq(::(@x_1, @x_2), leaf())] = [0]
>= [0]
= [#false()]
[#eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3))] = [0]
>= [0]
= [#false()]
[#eq(::(@x_1, @x_2), nil())] = [0]
>= [0]
= [#false()]
[#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [0]
>= [0]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(#0(), #pos(@y))] = [0]
>= [0]
= [#false()]
[#eq(#0(), #0())] = [0]
>= [0]
= [#true()]
[#eq(#0(), #neg(@y))] = [0]
>= [0]
= [#false()]
[#eq(#0(), #s(@y))] = [0]
>= [0]
= [#false()]
[#eq(#neg(@x), #pos(@y))] = [0]
>= [0]
= [#false()]
[#eq(#neg(@x), #0())] = [0]
>= [0]
= [#false()]
[#eq(#neg(@x), #neg(@y))] = [0]
>= [0]
= [#eq(@x, @y)]
[#eq(#s(@x), #0())] = [0]
>= [0]
= [#false()]
[#eq(#s(@x), #s(@y))] = [0]
>= [0]
= [#eq(@x, @y)]
[#and(#true(), #true())] = [0]
>= [0]
= [#true()]
[#and(#true(), #false())] = [0]
>= [0]
= [#false()]
[#and(#false(), #true())] = [0]
>= [0]
= [#false()]
[#and(#false(), #false())] = [0]
>= [0]
= [#false()]
[dfs#1^#(::(@t, @ts), @x)] = [4] @t + [4] @ts + [5]
>= [4] @t + [4] @ts + [5]
= [c_6(dfs#2^#(@t, @t, @ts, @x))]
[dfs#2^#(leaf(), @t, @ts, @x)] = [4] @ts + [13]
> [4] @ts + [5]
= [c_7(dfs^#(@ts, @x))]
[dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x)] = [4] @a + [4] @ts + [4] @t1 + [4] @t2 + [5]
>= [4] @ts + [4] @t1 + [4] @t2 + [5]
= [c_8(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))]
[dfs^#(@queue, @x)] = [4] @queue + [5]
>= [4] @queue + [5]
= [c_11(dfs#1^#(@queue, @x))]
[dfs#3^#(#false(), @t, @t1, @t2, @ts, @x)] = [4] @ts + [4] @t1 + [4] @t2 + [5]
>= [4] @ts + [4] @t1 + [4] @t2 + [5]
= [c_19(dfs^#(::(@t1, ::(@t2, @ts)), @x))]
The strictly oriented rules are moved into the weak component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ dfs#1^#(::(@t, @ts), @x) -> c_6(dfs#2^#(@t, @t, @ts, @x))
, dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_8(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
, dfs^#(@queue, @x) -> c_11(dfs#1^#(@queue, @x))
, dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_19(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
Weak DPs: { dfs#2^#(leaf(), @t, @ts, @x) -> c_7(dfs^#(@ts, @x)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We use the processor 'matrix interpretation of dimension 1' to
orient following rules strictly.
DPs:
{ 2: dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_8(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
, 4: dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_19(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
Trs: { #equal(@x, @y) -> #eq(@x, @y) }
Sub-proof:
----------
The following argument positions are usable:
Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1},
Uargs(c_11) = {1}, Uargs(c_19) = {1}
TcT has computed the following constructor-based matrix
interpretation satisfying not(EDA).
[#equal](x1, x2) = [2]
[#eq](x1, x2) = [1]
[#true] = [1]
[leaf] = [0]
[#pos](x1) = [1] x1 + [0]
[node](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [4]
[#and](x1, x2) = [1] x2 + [0]
[nil] = [0]
[#false] = [1]
[::](x1, x2) = [1] x1 + [1] x2 + [0]
[#0] = [0]
[#neg](x1) = [1] x1 + [0]
[#s](x1) = [1] x1 + [2]
[dfs#1^#](x1, x2) = [1] x1 + [4] x2 + [3]
[dfs#2^#](x1, x2, x3, x4) = [1] x1 + [1] x3 + [4] x4 + [3]
[dfs^#](x1, x2) = [1] x1 + [4] x2 + [3]
[dfs#3^#](x1, x2, x3, x4, x5, x6) = [1] x1 + [1] x3 + [1] x4 + [1] x5 + [4] x6 + [3]
[c_6](x1) = [1] x1 + [0]
[c_7](x1) = [1] x1 + [0]
[c_8](x1) = [1] x1 + [1]
[c_11](x1) = [1] x1 + [0]
[c_19](x1) = [1] x1 + [0]
The order satisfies the following ordering constraints:
[#equal(@x, @y)] = [2]
> [1]
= [#eq(@x, @y)]
[#eq(leaf(), leaf())] = [1]
>= [1]
= [#true()]
[#eq(leaf(), node(@y_1, @y_2, @y_3))] = [1]
>= [1]
= [#false()]
[#eq(leaf(), nil())] = [1]
>= [1]
= [#false()]
[#eq(leaf(), ::(@y_1, @y_2))] = [1]
>= [1]
= [#false()]
[#eq(#pos(@x), #pos(@y))] = [1]
>= [1]
= [#eq(@x, @y)]
[#eq(#pos(@x), #0())] = [1]
>= [1]
= [#false()]
[#eq(#pos(@x), #neg(@y))] = [1]
>= [1]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), leaf())] = [1]
>= [1]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3))] = [1]
>= [1]
= [#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))]
[#eq(node(@x_1, @x_2, @x_3), nil())] = [1]
>= [1]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2))] = [1]
>= [1]
= [#false()]
[#eq(nil(), leaf())] = [1]
>= [1]
= [#false()]
[#eq(nil(), node(@y_1, @y_2, @y_3))] = [1]
>= [1]
= [#false()]
[#eq(nil(), nil())] = [1]
>= [1]
= [#true()]
[#eq(nil(), ::(@y_1, @y_2))] = [1]
>= [1]
= [#false()]
[#eq(::(@x_1, @x_2), leaf())] = [1]
>= [1]
= [#false()]
[#eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3))] = [1]
>= [1]
= [#false()]
[#eq(::(@x_1, @x_2), nil())] = [1]
>= [1]
= [#false()]
[#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [1]
>= [1]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(#0(), #pos(@y))] = [1]
>= [1]
= [#false()]
[#eq(#0(), #0())] = [1]
>= [1]
= [#true()]
[#eq(#0(), #neg(@y))] = [1]
>= [1]
= [#false()]
[#eq(#0(), #s(@y))] = [1]
>= [1]
= [#false()]
[#eq(#neg(@x), #pos(@y))] = [1]
>= [1]
= [#false()]
[#eq(#neg(@x), #0())] = [1]
>= [1]
= [#false()]
[#eq(#neg(@x), #neg(@y))] = [1]
>= [1]
= [#eq(@x, @y)]
[#eq(#s(@x), #0())] = [1]
>= [1]
= [#false()]
[#eq(#s(@x), #s(@y))] = [1]
>= [1]
= [#eq(@x, @y)]
[#and(#true(), #true())] = [1]
>= [1]
= [#true()]
[#and(#true(), #false())] = [1]
>= [1]
= [#false()]
[#and(#false(), #true())] = [1]
>= [1]
= [#false()]
[#and(#false(), #false())] = [1]
>= [1]
= [#false()]
[dfs#1^#(::(@t, @ts), @x)] = [4] @x + [1] @t + [1] @ts + [3]
>= [4] @x + [1] @t + [1] @ts + [3]
= [c_6(dfs#2^#(@t, @t, @ts, @x))]
[dfs#2^#(leaf(), @t, @ts, @x)] = [4] @x + [1] @ts + [3]
>= [4] @x + [1] @ts + [3]
= [c_7(dfs^#(@ts, @x))]
[dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x)] = [4] @x + [1] @a + [1] @ts + [1] @t1 + [1] @t2 + [7]
> [4] @x + [1] @ts + [1] @t1 + [1] @t2 + [6]
= [c_8(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))]
[dfs^#(@queue, @x)] = [4] @x + [1] @queue + [3]
>= [4] @x + [1] @queue + [3]
= [c_11(dfs#1^#(@queue, @x))]
[dfs#3^#(#false(), @t, @t1, @t2, @ts, @x)] = [4] @x + [1] @ts + [1] @t1 + [1] @t2 + [4]
> [4] @x + [1] @ts + [1] @t1 + [1] @t2 + [3]
= [c_19(dfs^#(::(@t1, ::(@t2, @ts)), @x))]
The strictly oriented rules are moved into the weak component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ dfs#1^#(::(@t, @ts), @x) -> c_6(dfs#2^#(@t, @t, @ts, @x))
, dfs^#(@queue, @x) -> c_11(dfs#1^#(@queue, @x)) }
Weak DPs:
{ dfs#2^#(leaf(), @t, @ts, @x) -> c_7(dfs^#(@ts, @x))
, dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_8(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
, dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_19(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We use the processor 'matrix interpretation of dimension 1' to
orient following rules strictly.
DPs:
{ 2: dfs^#(@queue, @x) -> c_11(dfs#1^#(@queue, @x))
, 3: dfs#2^#(leaf(), @t, @ts, @x) -> c_7(dfs^#(@ts, @x)) }
Sub-proof:
----------
The following argument positions are usable:
Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1},
Uargs(c_11) = {1}, Uargs(c_19) = {1}
TcT has computed the following constructor-based matrix
interpretation satisfying not(EDA).
[#equal](x1, x2) = [0]
[#eq](x1, x2) = [0]
[#true] = [0]
[leaf] = [5]
[#pos](x1) = [1] x1 + [0]
[node](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [4]
[#and](x1, x2) = [0]
[nil] = [0]
[#false] = [0]
[::](x1, x2) = [1] x1 + [1] x2 + [0]
[#0] = [0]
[#neg](x1) = [1] x1 + [0]
[#s](x1) = [1] x1 + [0]
[dfs#1^#](x1, x2) = [1] x1 + [0]
[dfs#2^#](x1, x2, x3, x4) = [1] x1 + [1] x3 + [0]
[dfs^#](x1, x2) = [1] x1 + [4]
[dfs#3^#](x1, x2, x3, x4, x5, x6) = [1] x3 + [1] x4 + [1] x5 + [4]
[c_6](x1) = [1] x1 + [0]
[c_7](x1) = [1] x1 + [0]
[c_8](x1) = [1] x1 + [0]
[c_11](x1) = [1] x1 + [1]
[c_19](x1) = [1] x1 + [0]
The order satisfies the following ordering constraints:
[#equal(@x, @y)] = [0]
>= [0]
= [#eq(@x, @y)]
[#eq(leaf(), leaf())] = [0]
>= [0]
= [#true()]
[#eq(leaf(), node(@y_1, @y_2, @y_3))] = [0]
>= [0]
= [#false()]
[#eq(leaf(), nil())] = [0]
>= [0]
= [#false()]
[#eq(leaf(), ::(@y_1, @y_2))] = [0]
>= [0]
= [#false()]
[#eq(#pos(@x), #pos(@y))] = [0]
>= [0]
= [#eq(@x, @y)]
[#eq(#pos(@x), #0())] = [0]
>= [0]
= [#false()]
[#eq(#pos(@x), #neg(@y))] = [0]
>= [0]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), leaf())] = [0]
>= [0]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3))] = [0]
>= [0]
= [#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))]
[#eq(node(@x_1, @x_2, @x_3), nil())] = [0]
>= [0]
= [#false()]
[#eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2))] = [0]
>= [0]
= [#false()]
[#eq(nil(), leaf())] = [0]
>= [0]
= [#false()]
[#eq(nil(), node(@y_1, @y_2, @y_3))] = [0]
>= [0]
= [#false()]
[#eq(nil(), nil())] = [0]
>= [0]
= [#true()]
[#eq(nil(), ::(@y_1, @y_2))] = [0]
>= [0]
= [#false()]
[#eq(::(@x_1, @x_2), leaf())] = [0]
>= [0]
= [#false()]
[#eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3))] = [0]
>= [0]
= [#false()]
[#eq(::(@x_1, @x_2), nil())] = [0]
>= [0]
= [#false()]
[#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [0]
>= [0]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(#0(), #pos(@y))] = [0]
>= [0]
= [#false()]
[#eq(#0(), #0())] = [0]
>= [0]
= [#true()]
[#eq(#0(), #neg(@y))] = [0]
>= [0]
= [#false()]
[#eq(#0(), #s(@y))] = [0]
>= [0]
= [#false()]
[#eq(#neg(@x), #pos(@y))] = [0]
>= [0]
= [#false()]
[#eq(#neg(@x), #0())] = [0]
>= [0]
= [#false()]
[#eq(#neg(@x), #neg(@y))] = [0]
>= [0]
= [#eq(@x, @y)]
[#eq(#s(@x), #0())] = [0]
>= [0]
= [#false()]
[#eq(#s(@x), #s(@y))] = [0]
>= [0]
= [#eq(@x, @y)]
[#and(#true(), #true())] = [0]
>= [0]
= [#true()]
[#and(#true(), #false())] = [0]
>= [0]
= [#false()]
[#and(#false(), #true())] = [0]
>= [0]
= [#false()]
[#and(#false(), #false())] = [0]
>= [0]
= [#false()]
[dfs#1^#(::(@t, @ts), @x)] = [1] @t + [1] @ts + [0]
>= [1] @t + [1] @ts + [0]
= [c_6(dfs#2^#(@t, @t, @ts, @x))]
[dfs#2^#(leaf(), @t, @ts, @x)] = [1] @ts + [5]
> [1] @ts + [4]
= [c_7(dfs^#(@ts, @x))]
[dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x)] = [1] @a + [1] @ts + [1] @t1 + [1] @t2 + [4]
>= [1] @ts + [1] @t1 + [1] @t2 + [4]
= [c_8(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))]
[dfs^#(@queue, @x)] = [1] @queue + [4]
> [1] @queue + [1]
= [c_11(dfs#1^#(@queue, @x))]
[dfs#3^#(#false(), @t, @t1, @t2, @ts, @x)] = [1] @ts + [1] @t1 + [1] @t2 + [4]
>= [1] @ts + [1] @t1 + [1] @t2 + [4]
= [c_19(dfs^#(::(@t1, ::(@t2, @ts)), @x))]
We return to the main proof. Consider the set of all dependency
pairs
:
{ 1: dfs#1^#(::(@t, @ts), @x) -> c_6(dfs#2^#(@t, @t, @ts, @x))
, 2: dfs^#(@queue, @x) -> c_11(dfs#1^#(@queue, @x))
, 3: dfs#2^#(leaf(), @t, @ts, @x) -> c_7(dfs^#(@ts, @x))
, 4: dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_8(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
, 5: dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_19(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
Processor 'matrix interpretation of dimension 1' induces the
complexity certificate YES(?,O(n^1)) on application of dependency
pairs {2,3}. These cover all (indirect) predecessors of dependency
pairs {1,2,3,4,5}, their number of application is equally bounded.
The dependency pairs are shifted into the weak component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Weak DPs:
{ dfs#1^#(::(@t, @ts), @x) -> c_6(dfs#2^#(@t, @t, @ts, @x))
, dfs#2^#(leaf(), @t, @ts, @x) -> c_7(dfs^#(@ts, @x))
, dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_8(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
, dfs^#(@queue, @x) -> c_11(dfs#1^#(@queue, @x))
, dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_19(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
The following weak DPs constitute a sub-graph of the DG that is
closed under successors. The DPs are removed.
{ dfs#1^#(::(@t, @ts), @x) -> c_6(dfs#2^#(@t, @t, @ts, @x))
, dfs#2^#(leaf(), @t, @ts, @x) -> c_7(dfs^#(@ts, @x))
, dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
c_8(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
, dfs^#(@queue, @x) -> c_11(dfs#1^#(@queue, @x))
, dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
c_19(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(leaf(), leaf()) -> #true()
, #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(leaf(), nil()) -> #false()
, #eq(leaf(), ::(@y_1, @y_2)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
, #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
, #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), leaf()) -> #false()
, #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(::(@x_1, @x_2), leaf()) -> #false()
, #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #and(#true(), #true()) -> #true()
, #and(#true(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#false(), #false()) -> #false() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
No rule is usable, rules are removed from the input problem.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Rules: Empty
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
Empty rules are trivially bounded
Hurray, we answered YES(O(1),O(n^2))