tct
MAYBE
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs)) }
Weak Trs:
{ #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We add following dependency tuples
Strict DPs:
{ #equal^#(@x, @y) -> #eq^#(@x, @y)
, #greater^#(@x, @y) ->
c_2(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y))
, append^#(@l, @ys) -> append#1^#(@l, @ys)
, append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, append#1^#(nil(), @ys) -> c_5()
, insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#2^#(nil(), @keyX, @valX, @x) -> c_9()
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX))
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) -> c_12()
, quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_14(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#1^#(nil()) -> c_15()
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_17(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs))
, splitqs#1^#(nil(), @pivot) -> c_27()
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#1^#(nil()) -> c_20()
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_21(quicksort^#(@vals), sortAll^#(@xs))
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_23(insert^#(@x, split(@xs)), split^#(@xs))
, split#1^#(nil()) -> c_24()
, splitAndSort^#(@l) -> c_25(sortAll^#(split(@l)), split^#(@l))
, splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
#greater^#(@x, @pivot))
, splitqs#3^#(#false(), @ls, @rs, @x) -> c_29()
, splitqs#3^#(#true(), @ls, @rs, @x) -> c_30() }
Weak DPs:
{ #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, #eq^#(::(@x_1, @x_2), nil()) -> c_32()
, #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33()
, #eq^#(nil(), ::(@y_1, @y_2)) -> c_34()
, #eq^#(nil(), nil()) -> c_35()
, #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36()
, #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37()
, #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38()
, #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, #eq^#(#0(), #0()) -> c_40()
, #eq^#(#0(), #neg(@y)) -> c_41()
, #eq^#(#0(), #pos(@y)) -> c_42()
, #eq^#(#0(), #s(@y)) -> c_43()
, #eq^#(#neg(@x), #0()) -> c_44()
, #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y)
, #eq^#(#neg(@x), #pos(@y)) -> c_46()
, #eq^#(#pos(@x), #0()) -> c_47()
, #eq^#(#pos(@x), #neg(@y)) -> c_48()
, #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y)
, #eq^#(#s(@x), #0()) -> c_50()
, #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y)
, #ckgt^#(#EQ()) -> c_64()
, #ckgt^#(#GT()) -> c_65()
, #ckgt^#(#LT()) -> c_66()
, #compare^#(#0(), #0()) -> c_52()
, #compare^#(#0(), #neg(@y)) -> c_53()
, #compare^#(#0(), #pos(@y)) -> c_54()
, #compare^#(#0(), #s(@y)) -> c_55()
, #compare^#(#neg(@x), #0()) -> c_56()
, #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x)
, #compare^#(#neg(@x), #pos(@y)) -> c_58()
, #compare^#(#pos(@x), #0()) -> c_59()
, #compare^#(#pos(@x), #neg(@y)) -> c_60()
, #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y)
, #compare^#(#s(@x), #0()) -> c_62()
, #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y)
, #and^#(#false(), #false()) -> c_67()
, #and^#(#false(), #true()) -> c_68()
, #and^#(#true(), #false()) -> c_69()
, #and^#(#true(), #true()) -> c_70() }
and replace the set of basic marked basic terms accordingly.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ #equal^#(@x, @y) -> #eq^#(@x, @y)
, #greater^#(@x, @y) ->
c_2(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y))
, append^#(@l, @ys) -> append#1^#(@l, @ys)
, append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, append#1^#(nil(), @ys) -> c_5()
, insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#2^#(nil(), @keyX, @valX, @x) -> c_9()
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX))
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) -> c_12()
, quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_14(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#1^#(nil()) -> c_15()
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_17(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs))
, splitqs#1^#(nil(), @pivot) -> c_27()
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#1^#(nil()) -> c_20()
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_21(quicksort^#(@vals), sortAll^#(@xs))
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_23(insert^#(@x, split(@xs)), split^#(@xs))
, split#1^#(nil()) -> c_24()
, splitAndSort^#(@l) -> c_25(sortAll^#(split(@l)), split^#(@l))
, splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
#greater^#(@x, @pivot))
, splitqs#3^#(#false(), @ls, @rs, @x) -> c_29()
, splitqs#3^#(#true(), @ls, @rs, @x) -> c_30() }
Weak DPs:
{ #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, #eq^#(::(@x_1, @x_2), nil()) -> c_32()
, #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33()
, #eq^#(nil(), ::(@y_1, @y_2)) -> c_34()
, #eq^#(nil(), nil()) -> c_35()
, #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36()
, #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37()
, #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38()
, #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, #eq^#(#0(), #0()) -> c_40()
, #eq^#(#0(), #neg(@y)) -> c_41()
, #eq^#(#0(), #pos(@y)) -> c_42()
, #eq^#(#0(), #s(@y)) -> c_43()
, #eq^#(#neg(@x), #0()) -> c_44()
, #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y)
, #eq^#(#neg(@x), #pos(@y)) -> c_46()
, #eq^#(#pos(@x), #0()) -> c_47()
, #eq^#(#pos(@x), #neg(@y)) -> c_48()
, #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y)
, #eq^#(#s(@x), #0()) -> c_50()
, #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y)
, #ckgt^#(#EQ()) -> c_64()
, #ckgt^#(#GT()) -> c_65()
, #ckgt^#(#LT()) -> c_66()
, #compare^#(#0(), #0()) -> c_52()
, #compare^#(#0(), #neg(@y)) -> c_53()
, #compare^#(#0(), #pos(@y)) -> c_54()
, #compare^#(#0(), #s(@y)) -> c_55()
, #compare^#(#neg(@x), #0()) -> c_56()
, #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x)
, #compare^#(#neg(@x), #pos(@y)) -> c_58()
, #compare^#(#pos(@x), #0()) -> c_59()
, #compare^#(#pos(@x), #neg(@y)) -> c_60()
, #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y)
, #compare^#(#s(@x), #0()) -> c_62()
, #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y)
, #and^#(#false(), #false()) -> c_67()
, #and^#(#false(), #true()) -> c_68()
, #and^#(#true(), #false()) -> c_69()
, #and^#(#true(), #true()) -> c_70() }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: #equal^#(@x, @y) -> #eq^#(@x, @y)
-->_1 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :51
-->_1 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :49
-->_1 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :45
-->_1 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :39
-->_1 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :31
-->_1 #eq^#(#s(@x), #0()) -> c_50() :50
-->_1 #eq^#(#pos(@x), #neg(@y)) -> c_48() :48
-->_1 #eq^#(#pos(@x), #0()) -> c_47() :47
-->_1 #eq^#(#neg(@x), #pos(@y)) -> c_46() :46
-->_1 #eq^#(#neg(@x), #0()) -> c_44() :44
-->_1 #eq^#(#0(), #s(@y)) -> c_43() :43
-->_1 #eq^#(#0(), #pos(@y)) -> c_42() :42
-->_1 #eq^#(#0(), #neg(@y)) -> c_41() :41
-->_1 #eq^#(#0(), #0()) -> c_40() :40
-->_1 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :38
-->_1 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :37
-->_1 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :36
-->_1 #eq^#(nil(), nil()) -> c_35() :35
-->_1 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :34
-->_1 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :33
-->_1 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :32
2: #greater^#(@x, @y) ->
c_2(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y))
-->_2 #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y) :66
-->_2 #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y) :64
-->_2 #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x) :60
-->_2 #compare^#(#s(@x), #0()) -> c_62() :65
-->_2 #compare^#(#pos(@x), #neg(@y)) -> c_60() :63
-->_2 #compare^#(#pos(@x), #0()) -> c_59() :62
-->_2 #compare^#(#neg(@x), #pos(@y)) -> c_58() :61
-->_2 #compare^#(#neg(@x), #0()) -> c_56() :59
-->_2 #compare^#(#0(), #s(@y)) -> c_55() :58
-->_2 #compare^#(#0(), #pos(@y)) -> c_54() :57
-->_2 #compare^#(#0(), #neg(@y)) -> c_53() :56
-->_2 #compare^#(#0(), #0()) -> c_52() :55
-->_1 #ckgt^#(#LT()) -> c_66() :54
-->_1 #ckgt^#(#GT()) -> c_65() :53
-->_1 #ckgt^#(#EQ()) -> c_64() :52
3: append^#(@l, @ys) -> append#1^#(@l, @ys)
-->_1 append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys) :4
-->_1 append#1^#(nil(), @ys) -> c_5() :5
4: append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :3
5: append#1^#(nil(), @ys) -> c_5()
6: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
-->_1 insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x) :7
7: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
-->_1 insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x) :8
-->_1 insert#2^#(nil(), @keyX, @valX, @x) -> c_9() :9
8: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
-->_1 insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX)) :10
9: insert#2^#(nil(), @keyX, @valX, @x) -> c_9()
10: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX))
-->_1 insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) :11
-->_1 insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) ->
c_12() :12
-->_2 #equal^#(@x, @y) -> #eq^#(@x, @y) :1
11: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :6
12: insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) -> c_12()
13: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_14(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :14
-->_1 quicksort#1^#(nil()) -> c_15() :15
14: quicksort#1^#(::(@z, @zs)) ->
c_14(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :17
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_17(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :16
15: quicksort#1^#(nil()) -> c_15()
16: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_17(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :13
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :13
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :3
17: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
-->_1 splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs)) :18
-->_1 splitqs#1^#(nil(), @pivot) -> c_27() :19
18: splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs))
-->_1 splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
#greater^#(@x, @pivot)) :28
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :17
19: splitqs#1^#(nil(), @pivot) -> c_27()
20: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :21
-->_1 sortAll#1^#(nil()) -> c_20() :22
21: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_21(quicksort^#(@vals), sortAll^#(@xs)) :23
22: sortAll#1^#(nil()) -> c_20()
23: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_21(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :20
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :13
24: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) ->
c_23(insert^#(@x, split(@xs)), split^#(@xs)) :25
-->_1 split#1^#(nil()) -> c_24() :26
25: split#1^#(::(@x, @xs)) ->
c_23(insert^#(@x, split(@xs)), split^#(@xs))
-->_2 split^#(@l) -> split#1^#(@l) :24
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :6
26: split#1^#(nil()) -> c_24()
27: splitAndSort^#(@l) -> c_25(sortAll^#(split(@l)), split^#(@l))
-->_2 split^#(@l) -> split#1^#(@l) :24
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :20
28: splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
#greater^#(@x, @pivot))
-->_1 splitqs#3^#(#true(), @ls, @rs, @x) -> c_30() :30
-->_1 splitqs#3^#(#false(), @ls, @rs, @x) -> c_29() :29
-->_2 #greater^#(@x, @y) ->
c_2(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y)) :2
29: splitqs#3^#(#false(), @ls, @rs, @x) -> c_29()
30: splitqs#3^#(#true(), @ls, @rs, @x) -> c_30()
31: #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
-->_3 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :51
-->_2 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :51
-->_3 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :49
-->_2 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :49
-->_3 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :45
-->_2 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :45
-->_3 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :39
-->_2 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :39
-->_1 #and^#(#true(), #true()) -> c_70() :70
-->_1 #and^#(#true(), #false()) -> c_69() :69
-->_1 #and^#(#false(), #true()) -> c_68() :68
-->_1 #and^#(#false(), #false()) -> c_67() :67
-->_3 #eq^#(#s(@x), #0()) -> c_50() :50
-->_2 #eq^#(#s(@x), #0()) -> c_50() :50
-->_3 #eq^#(#pos(@x), #neg(@y)) -> c_48() :48
-->_2 #eq^#(#pos(@x), #neg(@y)) -> c_48() :48
-->_3 #eq^#(#pos(@x), #0()) -> c_47() :47
-->_2 #eq^#(#pos(@x), #0()) -> c_47() :47
-->_3 #eq^#(#neg(@x), #pos(@y)) -> c_46() :46
-->_2 #eq^#(#neg(@x), #pos(@y)) -> c_46() :46
-->_3 #eq^#(#neg(@x), #0()) -> c_44() :44
-->_2 #eq^#(#neg(@x), #0()) -> c_44() :44
-->_3 #eq^#(#0(), #s(@y)) -> c_43() :43
-->_2 #eq^#(#0(), #s(@y)) -> c_43() :43
-->_3 #eq^#(#0(), #pos(@y)) -> c_42() :42
-->_2 #eq^#(#0(), #pos(@y)) -> c_42() :42
-->_3 #eq^#(#0(), #neg(@y)) -> c_41() :41
-->_2 #eq^#(#0(), #neg(@y)) -> c_41() :41
-->_3 #eq^#(#0(), #0()) -> c_40() :40
-->_2 #eq^#(#0(), #0()) -> c_40() :40
-->_3 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :38
-->_2 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :38
-->_3 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :37
-->_2 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :37
-->_3 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :36
-->_2 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :36
-->_3 #eq^#(nil(), nil()) -> c_35() :35
-->_2 #eq^#(nil(), nil()) -> c_35() :35
-->_3 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :34
-->_2 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :34
-->_3 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :33
-->_2 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :33
-->_3 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :32
-->_2 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :32
-->_3 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :31
-->_2 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :31
32: #eq^#(::(@x_1, @x_2), nil()) -> c_32()
33: #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33()
34: #eq^#(nil(), ::(@y_1, @y_2)) -> c_34()
35: #eq^#(nil(), nil()) -> c_35()
36: #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36()
37: #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37()
38: #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38()
39: #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
-->_3 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :51
-->_2 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :51
-->_3 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :49
-->_2 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :49
-->_3 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :45
-->_2 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :45
-->_1 #and^#(#true(), #true()) -> c_70() :70
-->_1 #and^#(#true(), #false()) -> c_69() :69
-->_1 #and^#(#false(), #true()) -> c_68() :68
-->_1 #and^#(#false(), #false()) -> c_67() :67
-->_3 #eq^#(#s(@x), #0()) -> c_50() :50
-->_2 #eq^#(#s(@x), #0()) -> c_50() :50
-->_3 #eq^#(#pos(@x), #neg(@y)) -> c_48() :48
-->_2 #eq^#(#pos(@x), #neg(@y)) -> c_48() :48
-->_3 #eq^#(#pos(@x), #0()) -> c_47() :47
-->_2 #eq^#(#pos(@x), #0()) -> c_47() :47
-->_3 #eq^#(#neg(@x), #pos(@y)) -> c_46() :46
-->_2 #eq^#(#neg(@x), #pos(@y)) -> c_46() :46
-->_3 #eq^#(#neg(@x), #0()) -> c_44() :44
-->_2 #eq^#(#neg(@x), #0()) -> c_44() :44
-->_3 #eq^#(#0(), #s(@y)) -> c_43() :43
-->_2 #eq^#(#0(), #s(@y)) -> c_43() :43
-->_3 #eq^#(#0(), #pos(@y)) -> c_42() :42
-->_2 #eq^#(#0(), #pos(@y)) -> c_42() :42
-->_3 #eq^#(#0(), #neg(@y)) -> c_41() :41
-->_2 #eq^#(#0(), #neg(@y)) -> c_41() :41
-->_3 #eq^#(#0(), #0()) -> c_40() :40
-->_2 #eq^#(#0(), #0()) -> c_40() :40
-->_3 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :39
-->_2 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :39
-->_3 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :38
-->_2 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :38
-->_3 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :37
-->_2 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :37
-->_3 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :36
-->_2 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :36
-->_3 #eq^#(nil(), nil()) -> c_35() :35
-->_2 #eq^#(nil(), nil()) -> c_35() :35
-->_3 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :34
-->_2 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :34
-->_3 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :33
-->_2 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :33
-->_3 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :32
-->_2 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :32
-->_3 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :31
-->_2 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :31
40: #eq^#(#0(), #0()) -> c_40()
41: #eq^#(#0(), #neg(@y)) -> c_41()
42: #eq^#(#0(), #pos(@y)) -> c_42()
43: #eq^#(#0(), #s(@y)) -> c_43()
44: #eq^#(#neg(@x), #0()) -> c_44()
45: #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y)
-->_1 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :51
-->_1 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :49
-->_1 #eq^#(#s(@x), #0()) -> c_50() :50
-->_1 #eq^#(#pos(@x), #neg(@y)) -> c_48() :48
-->_1 #eq^#(#pos(@x), #0()) -> c_47() :47
-->_1 #eq^#(#neg(@x), #pos(@y)) -> c_46() :46
-->_1 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :45
-->_1 #eq^#(#neg(@x), #0()) -> c_44() :44
-->_1 #eq^#(#0(), #s(@y)) -> c_43() :43
-->_1 #eq^#(#0(), #pos(@y)) -> c_42() :42
-->_1 #eq^#(#0(), #neg(@y)) -> c_41() :41
-->_1 #eq^#(#0(), #0()) -> c_40() :40
-->_1 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :39
-->_1 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :38
-->_1 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :37
-->_1 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :36
-->_1 #eq^#(nil(), nil()) -> c_35() :35
-->_1 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :34
-->_1 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :33
-->_1 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :32
-->_1 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :31
46: #eq^#(#neg(@x), #pos(@y)) -> c_46()
47: #eq^#(#pos(@x), #0()) -> c_47()
48: #eq^#(#pos(@x), #neg(@y)) -> c_48()
49: #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y)
-->_1 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :51
-->_1 #eq^#(#s(@x), #0()) -> c_50() :50
-->_1 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :49
-->_1 #eq^#(#pos(@x), #neg(@y)) -> c_48() :48
-->_1 #eq^#(#pos(@x), #0()) -> c_47() :47
-->_1 #eq^#(#neg(@x), #pos(@y)) -> c_46() :46
-->_1 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :45
-->_1 #eq^#(#neg(@x), #0()) -> c_44() :44
-->_1 #eq^#(#0(), #s(@y)) -> c_43() :43
-->_1 #eq^#(#0(), #pos(@y)) -> c_42() :42
-->_1 #eq^#(#0(), #neg(@y)) -> c_41() :41
-->_1 #eq^#(#0(), #0()) -> c_40() :40
-->_1 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :39
-->_1 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :38
-->_1 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :37
-->_1 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :36
-->_1 #eq^#(nil(), nil()) -> c_35() :35
-->_1 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :34
-->_1 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :33
-->_1 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :32
-->_1 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :31
50: #eq^#(#s(@x), #0()) -> c_50()
51: #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y)
-->_1 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :51
-->_1 #eq^#(#s(@x), #0()) -> c_50() :50
-->_1 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :49
-->_1 #eq^#(#pos(@x), #neg(@y)) -> c_48() :48
-->_1 #eq^#(#pos(@x), #0()) -> c_47() :47
-->_1 #eq^#(#neg(@x), #pos(@y)) -> c_46() :46
-->_1 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :45
-->_1 #eq^#(#neg(@x), #0()) -> c_44() :44
-->_1 #eq^#(#0(), #s(@y)) -> c_43() :43
-->_1 #eq^#(#0(), #pos(@y)) -> c_42() :42
-->_1 #eq^#(#0(), #neg(@y)) -> c_41() :41
-->_1 #eq^#(#0(), #0()) -> c_40() :40
-->_1 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :39
-->_1 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :38
-->_1 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :37
-->_1 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :36
-->_1 #eq^#(nil(), nil()) -> c_35() :35
-->_1 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :34
-->_1 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :33
-->_1 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :32
-->_1 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :31
52: #ckgt^#(#EQ()) -> c_64()
53: #ckgt^#(#GT()) -> c_65()
54: #ckgt^#(#LT()) -> c_66()
55: #compare^#(#0(), #0()) -> c_52()
56: #compare^#(#0(), #neg(@y)) -> c_53()
57: #compare^#(#0(), #pos(@y)) -> c_54()
58: #compare^#(#0(), #s(@y)) -> c_55()
59: #compare^#(#neg(@x), #0()) -> c_56()
60: #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x)
-->_1 #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y) :66
-->_1 #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y) :64
-->_1 #compare^#(#s(@x), #0()) -> c_62() :65
-->_1 #compare^#(#pos(@x), #neg(@y)) -> c_60() :63
-->_1 #compare^#(#pos(@x), #0()) -> c_59() :62
-->_1 #compare^#(#neg(@x), #pos(@y)) -> c_58() :61
-->_1 #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x) :60
-->_1 #compare^#(#neg(@x), #0()) -> c_56() :59
-->_1 #compare^#(#0(), #s(@y)) -> c_55() :58
-->_1 #compare^#(#0(), #pos(@y)) -> c_54() :57
-->_1 #compare^#(#0(), #neg(@y)) -> c_53() :56
-->_1 #compare^#(#0(), #0()) -> c_52() :55
61: #compare^#(#neg(@x), #pos(@y)) -> c_58()
62: #compare^#(#pos(@x), #0()) -> c_59()
63: #compare^#(#pos(@x), #neg(@y)) -> c_60()
64: #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y)
-->_1 #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y) :66
-->_1 #compare^#(#s(@x), #0()) -> c_62() :65
-->_1 #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y) :64
-->_1 #compare^#(#pos(@x), #neg(@y)) -> c_60() :63
-->_1 #compare^#(#pos(@x), #0()) -> c_59() :62
-->_1 #compare^#(#neg(@x), #pos(@y)) -> c_58() :61
-->_1 #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x) :60
-->_1 #compare^#(#neg(@x), #0()) -> c_56() :59
-->_1 #compare^#(#0(), #s(@y)) -> c_55() :58
-->_1 #compare^#(#0(), #pos(@y)) -> c_54() :57
-->_1 #compare^#(#0(), #neg(@y)) -> c_53() :56
-->_1 #compare^#(#0(), #0()) -> c_52() :55
65: #compare^#(#s(@x), #0()) -> c_62()
66: #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y)
-->_1 #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y) :66
-->_1 #compare^#(#s(@x), #0()) -> c_62() :65
-->_1 #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y) :64
-->_1 #compare^#(#pos(@x), #neg(@y)) -> c_60() :63
-->_1 #compare^#(#pos(@x), #0()) -> c_59() :62
-->_1 #compare^#(#neg(@x), #pos(@y)) -> c_58() :61
-->_1 #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x) :60
-->_1 #compare^#(#neg(@x), #0()) -> c_56() :59
-->_1 #compare^#(#0(), #s(@y)) -> c_55() :58
-->_1 #compare^#(#0(), #pos(@y)) -> c_54() :57
-->_1 #compare^#(#0(), #neg(@y)) -> c_53() :56
-->_1 #compare^#(#0(), #0()) -> c_52() :55
67: #and^#(#false(), #false()) -> c_67()
68: #and^#(#false(), #true()) -> c_68()
69: #and^#(#true(), #false()) -> c_69()
70: #and^#(#true(), #true()) -> c_70()
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {26} and add Pre({26}) = {24} to the strict component.
- We remove {22} and add Pre({22}) = {20} to the strict component.
- We remove {15} and add Pre({15}) = {13} to the strict component.
- We remove {19} and add Pre({19}) = {17} to the strict component.
- We remove {29} and add Pre({29}) = {28} to the strict component.
- We remove {30} and add Pre({30}) = {28} to the strict component.
- We remove {9} and add Pre({9}) = {7} to the strict component.
- We remove {12} and add Pre({12}) = {10} to the strict component.
- We remove {5} and add Pre({5}) = {3} to the strict component.
- We remove {2} and add Pre({2}) = {28} to the strict component.
- We remove {1} and add Pre({1}) = {10} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX))
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_14(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_17(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_21(quicksort^#(@vals), sortAll^#(@xs))
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_23(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> c_25(sortAll^#(split(@l)), split^#(@l))
, splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
#greater^#(@x, @pivot)) }
Weak DPs:
{ #equal^#(@x, @y) -> #eq^#(@x, @y)
, #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, #eq^#(::(@x_1, @x_2), nil()) -> c_32()
, #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33()
, #eq^#(nil(), ::(@y_1, @y_2)) -> c_34()
, #eq^#(nil(), nil()) -> c_35()
, #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36()
, #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37()
, #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38()
, #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, #eq^#(#0(), #0()) -> c_40()
, #eq^#(#0(), #neg(@y)) -> c_41()
, #eq^#(#0(), #pos(@y)) -> c_42()
, #eq^#(#0(), #s(@y)) -> c_43()
, #eq^#(#neg(@x), #0()) -> c_44()
, #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y)
, #eq^#(#neg(@x), #pos(@y)) -> c_46()
, #eq^#(#pos(@x), #0()) -> c_47()
, #eq^#(#pos(@x), #neg(@y)) -> c_48()
, #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y)
, #eq^#(#s(@x), #0()) -> c_50()
, #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y)
, #greater^#(@x, @y) ->
c_2(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y))
, #ckgt^#(#EQ()) -> c_64()
, #ckgt^#(#GT()) -> c_65()
, #ckgt^#(#LT()) -> c_66()
, #compare^#(#0(), #0()) -> c_52()
, #compare^#(#0(), #neg(@y)) -> c_53()
, #compare^#(#0(), #pos(@y)) -> c_54()
, #compare^#(#0(), #s(@y)) -> c_55()
, #compare^#(#neg(@x), #0()) -> c_56()
, #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x)
, #compare^#(#neg(@x), #pos(@y)) -> c_58()
, #compare^#(#pos(@x), #0()) -> c_59()
, #compare^#(#pos(@x), #neg(@y)) -> c_60()
, #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y)
, #compare^#(#s(@x), #0()) -> c_62()
, #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y)
, append#1^#(nil(), @ys) -> c_5()
, insert#2^#(nil(), @keyX, @valX, @x) -> c_9()
, insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) -> c_12()
, quicksort#1^#(nil()) -> c_15()
, splitqs#1^#(nil(), @pivot) -> c_27()
, sortAll#1^#(nil()) -> c_20()
, split#1^#(nil()) -> c_24()
, splitqs#3^#(#false(), @ls, @rs, @x) -> c_29()
, splitqs#3^#(#true(), @ls, @rs, @x) -> c_30()
, #and^#(#false(), #false()) -> c_67()
, #and^#(#false(), #true()) -> c_68()
, #and^#(#true(), #false()) -> c_69()
, #and^#(#true(), #true()) -> c_70() }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append^#(@l, @ys) -> append#1^#(@l, @ys)
-->_1 append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys) :2
-->_1 append#1^#(nil(), @ys) -> c_5() :58
2: append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
3: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
-->_1 insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x) :4
4: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
-->_1 insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x) :5
-->_1 insert#2^#(nil(), @keyX, @valX, @x) -> c_9() :59
5: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
-->_1 insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX)) :6
6: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX))
-->_2 #equal^#(@x, @y) -> #eq^#(@x, @y) :20
-->_1 insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) :7
-->_1 insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) ->
c_12() :60
7: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :3
8: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_14(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :9
-->_1 quicksort#1^#(nil()) -> c_15() :61
9: quicksort#1^#(::(@z, @zs)) ->
c_14(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :11
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_17(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :10
10: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_17(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :8
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :8
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
11: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
-->_1 splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs)) :12
-->_1 splitqs#1^#(nil(), @pivot) -> c_27() :62
12: splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs))
-->_1 splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
#greater^#(@x, @pivot)) :19
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :11
13: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :14
-->_1 sortAll#1^#(nil()) -> c_20() :63
14: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_21(quicksort^#(@vals), sortAll^#(@xs)) :15
15: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_21(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :13
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :8
16: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) ->
c_23(insert^#(@x, split(@xs)), split^#(@xs)) :17
-->_1 split#1^#(nil()) -> c_24() :64
17: split#1^#(::(@x, @xs)) ->
c_23(insert^#(@x, split(@xs)), split^#(@xs))
-->_2 split^#(@l) -> split#1^#(@l) :16
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :3
18: splitAndSort^#(@l) -> c_25(sortAll^#(split(@l)), split^#(@l))
-->_2 split^#(@l) -> split#1^#(@l) :16
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :13
19: splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
#greater^#(@x, @pivot))
-->_2 #greater^#(@x, @y) ->
c_2(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y)) :42
-->_1 splitqs#3^#(#true(), @ls, @rs, @x) -> c_30() :66
-->_1 splitqs#3^#(#false(), @ls, @rs, @x) -> c_29() :65
20: #equal^#(@x, @y) -> #eq^#(@x, @y)
-->_1 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :41
-->_1 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :39
-->_1 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :35
-->_1 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :29
-->_1 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :21
-->_1 #eq^#(#s(@x), #0()) -> c_50() :40
-->_1 #eq^#(#pos(@x), #neg(@y)) -> c_48() :38
-->_1 #eq^#(#pos(@x), #0()) -> c_47() :37
-->_1 #eq^#(#neg(@x), #pos(@y)) -> c_46() :36
-->_1 #eq^#(#neg(@x), #0()) -> c_44() :34
-->_1 #eq^#(#0(), #s(@y)) -> c_43() :33
-->_1 #eq^#(#0(), #pos(@y)) -> c_42() :32
-->_1 #eq^#(#0(), #neg(@y)) -> c_41() :31
-->_1 #eq^#(#0(), #0()) -> c_40() :30
-->_1 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :28
-->_1 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :27
-->_1 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :26
-->_1 #eq^#(nil(), nil()) -> c_35() :25
-->_1 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :24
-->_1 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :23
-->_1 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :22
21: #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
-->_3 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :41
-->_2 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :41
-->_3 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :39
-->_2 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :39
-->_3 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :35
-->_2 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :35
-->_3 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :29
-->_2 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :29
-->_1 #and^#(#true(), #true()) -> c_70() :70
-->_1 #and^#(#true(), #false()) -> c_69() :69
-->_1 #and^#(#false(), #true()) -> c_68() :68
-->_1 #and^#(#false(), #false()) -> c_67() :67
-->_3 #eq^#(#s(@x), #0()) -> c_50() :40
-->_2 #eq^#(#s(@x), #0()) -> c_50() :40
-->_3 #eq^#(#pos(@x), #neg(@y)) -> c_48() :38
-->_2 #eq^#(#pos(@x), #neg(@y)) -> c_48() :38
-->_3 #eq^#(#pos(@x), #0()) -> c_47() :37
-->_2 #eq^#(#pos(@x), #0()) -> c_47() :37
-->_3 #eq^#(#neg(@x), #pos(@y)) -> c_46() :36
-->_2 #eq^#(#neg(@x), #pos(@y)) -> c_46() :36
-->_3 #eq^#(#neg(@x), #0()) -> c_44() :34
-->_2 #eq^#(#neg(@x), #0()) -> c_44() :34
-->_3 #eq^#(#0(), #s(@y)) -> c_43() :33
-->_2 #eq^#(#0(), #s(@y)) -> c_43() :33
-->_3 #eq^#(#0(), #pos(@y)) -> c_42() :32
-->_2 #eq^#(#0(), #pos(@y)) -> c_42() :32
-->_3 #eq^#(#0(), #neg(@y)) -> c_41() :31
-->_2 #eq^#(#0(), #neg(@y)) -> c_41() :31
-->_3 #eq^#(#0(), #0()) -> c_40() :30
-->_2 #eq^#(#0(), #0()) -> c_40() :30
-->_3 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :28
-->_2 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :28
-->_3 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :27
-->_2 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :27
-->_3 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :26
-->_2 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :26
-->_3 #eq^#(nil(), nil()) -> c_35() :25
-->_2 #eq^#(nil(), nil()) -> c_35() :25
-->_3 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :24
-->_2 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :24
-->_3 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :23
-->_2 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :23
-->_3 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :22
-->_2 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :22
-->_3 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :21
-->_2 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :21
22: #eq^#(::(@x_1, @x_2), nil()) -> c_32()
23: #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33()
24: #eq^#(nil(), ::(@y_1, @y_2)) -> c_34()
25: #eq^#(nil(), nil()) -> c_35()
26: #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36()
27: #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37()
28: #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38()
29: #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
-->_3 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :41
-->_2 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :41
-->_3 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :39
-->_2 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :39
-->_3 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :35
-->_2 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :35
-->_1 #and^#(#true(), #true()) -> c_70() :70
-->_1 #and^#(#true(), #false()) -> c_69() :69
-->_1 #and^#(#false(), #true()) -> c_68() :68
-->_1 #and^#(#false(), #false()) -> c_67() :67
-->_3 #eq^#(#s(@x), #0()) -> c_50() :40
-->_2 #eq^#(#s(@x), #0()) -> c_50() :40
-->_3 #eq^#(#pos(@x), #neg(@y)) -> c_48() :38
-->_2 #eq^#(#pos(@x), #neg(@y)) -> c_48() :38
-->_3 #eq^#(#pos(@x), #0()) -> c_47() :37
-->_2 #eq^#(#pos(@x), #0()) -> c_47() :37
-->_3 #eq^#(#neg(@x), #pos(@y)) -> c_46() :36
-->_2 #eq^#(#neg(@x), #pos(@y)) -> c_46() :36
-->_3 #eq^#(#neg(@x), #0()) -> c_44() :34
-->_2 #eq^#(#neg(@x), #0()) -> c_44() :34
-->_3 #eq^#(#0(), #s(@y)) -> c_43() :33
-->_2 #eq^#(#0(), #s(@y)) -> c_43() :33
-->_3 #eq^#(#0(), #pos(@y)) -> c_42() :32
-->_2 #eq^#(#0(), #pos(@y)) -> c_42() :32
-->_3 #eq^#(#0(), #neg(@y)) -> c_41() :31
-->_2 #eq^#(#0(), #neg(@y)) -> c_41() :31
-->_3 #eq^#(#0(), #0()) -> c_40() :30
-->_2 #eq^#(#0(), #0()) -> c_40() :30
-->_3 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :29
-->_2 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :29
-->_3 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :28
-->_2 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :28
-->_3 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :27
-->_2 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :27
-->_3 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :26
-->_2 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :26
-->_3 #eq^#(nil(), nil()) -> c_35() :25
-->_2 #eq^#(nil(), nil()) -> c_35() :25
-->_3 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :24
-->_2 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :24
-->_3 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :23
-->_2 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :23
-->_3 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :22
-->_2 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :22
-->_3 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :21
-->_2 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :21
30: #eq^#(#0(), #0()) -> c_40()
31: #eq^#(#0(), #neg(@y)) -> c_41()
32: #eq^#(#0(), #pos(@y)) -> c_42()
33: #eq^#(#0(), #s(@y)) -> c_43()
34: #eq^#(#neg(@x), #0()) -> c_44()
35: #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y)
-->_1 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :41
-->_1 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :39
-->_1 #eq^#(#s(@x), #0()) -> c_50() :40
-->_1 #eq^#(#pos(@x), #neg(@y)) -> c_48() :38
-->_1 #eq^#(#pos(@x), #0()) -> c_47() :37
-->_1 #eq^#(#neg(@x), #pos(@y)) -> c_46() :36
-->_1 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :35
-->_1 #eq^#(#neg(@x), #0()) -> c_44() :34
-->_1 #eq^#(#0(), #s(@y)) -> c_43() :33
-->_1 #eq^#(#0(), #pos(@y)) -> c_42() :32
-->_1 #eq^#(#0(), #neg(@y)) -> c_41() :31
-->_1 #eq^#(#0(), #0()) -> c_40() :30
-->_1 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :29
-->_1 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :28
-->_1 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :27
-->_1 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :26
-->_1 #eq^#(nil(), nil()) -> c_35() :25
-->_1 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :24
-->_1 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :23
-->_1 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :22
-->_1 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :21
36: #eq^#(#neg(@x), #pos(@y)) -> c_46()
37: #eq^#(#pos(@x), #0()) -> c_47()
38: #eq^#(#pos(@x), #neg(@y)) -> c_48()
39: #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y)
-->_1 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :41
-->_1 #eq^#(#s(@x), #0()) -> c_50() :40
-->_1 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :39
-->_1 #eq^#(#pos(@x), #neg(@y)) -> c_48() :38
-->_1 #eq^#(#pos(@x), #0()) -> c_47() :37
-->_1 #eq^#(#neg(@x), #pos(@y)) -> c_46() :36
-->_1 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :35
-->_1 #eq^#(#neg(@x), #0()) -> c_44() :34
-->_1 #eq^#(#0(), #s(@y)) -> c_43() :33
-->_1 #eq^#(#0(), #pos(@y)) -> c_42() :32
-->_1 #eq^#(#0(), #neg(@y)) -> c_41() :31
-->_1 #eq^#(#0(), #0()) -> c_40() :30
-->_1 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :29
-->_1 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :28
-->_1 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :27
-->_1 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :26
-->_1 #eq^#(nil(), nil()) -> c_35() :25
-->_1 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :24
-->_1 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :23
-->_1 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :22
-->_1 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :21
40: #eq^#(#s(@x), #0()) -> c_50()
41: #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y)
-->_1 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :41
-->_1 #eq^#(#s(@x), #0()) -> c_50() :40
-->_1 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :39
-->_1 #eq^#(#pos(@x), #neg(@y)) -> c_48() :38
-->_1 #eq^#(#pos(@x), #0()) -> c_47() :37
-->_1 #eq^#(#neg(@x), #pos(@y)) -> c_46() :36
-->_1 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :35
-->_1 #eq^#(#neg(@x), #0()) -> c_44() :34
-->_1 #eq^#(#0(), #s(@y)) -> c_43() :33
-->_1 #eq^#(#0(), #pos(@y)) -> c_42() :32
-->_1 #eq^#(#0(), #neg(@y)) -> c_41() :31
-->_1 #eq^#(#0(), #0()) -> c_40() :30
-->_1 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :29
-->_1 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :28
-->_1 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :27
-->_1 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :26
-->_1 #eq^#(nil(), nil()) -> c_35() :25
-->_1 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :24
-->_1 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :23
-->_1 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :22
-->_1 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :21
42: #greater^#(@x, @y) ->
c_2(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y))
-->_2 #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y) :57
-->_2 #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y) :55
-->_2 #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x) :51
-->_2 #compare^#(#s(@x), #0()) -> c_62() :56
-->_2 #compare^#(#pos(@x), #neg(@y)) -> c_60() :54
-->_2 #compare^#(#pos(@x), #0()) -> c_59() :53
-->_2 #compare^#(#neg(@x), #pos(@y)) -> c_58() :52
-->_2 #compare^#(#neg(@x), #0()) -> c_56() :50
-->_2 #compare^#(#0(), #s(@y)) -> c_55() :49
-->_2 #compare^#(#0(), #pos(@y)) -> c_54() :48
-->_2 #compare^#(#0(), #neg(@y)) -> c_53() :47
-->_2 #compare^#(#0(), #0()) -> c_52() :46
-->_1 #ckgt^#(#LT()) -> c_66() :45
-->_1 #ckgt^#(#GT()) -> c_65() :44
-->_1 #ckgt^#(#EQ()) -> c_64() :43
43: #ckgt^#(#EQ()) -> c_64()
44: #ckgt^#(#GT()) -> c_65()
45: #ckgt^#(#LT()) -> c_66()
46: #compare^#(#0(), #0()) -> c_52()
47: #compare^#(#0(), #neg(@y)) -> c_53()
48: #compare^#(#0(), #pos(@y)) -> c_54()
49: #compare^#(#0(), #s(@y)) -> c_55()
50: #compare^#(#neg(@x), #0()) -> c_56()
51: #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x)
-->_1 #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y) :57
-->_1 #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y) :55
-->_1 #compare^#(#s(@x), #0()) -> c_62() :56
-->_1 #compare^#(#pos(@x), #neg(@y)) -> c_60() :54
-->_1 #compare^#(#pos(@x), #0()) -> c_59() :53
-->_1 #compare^#(#neg(@x), #pos(@y)) -> c_58() :52
-->_1 #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x) :51
-->_1 #compare^#(#neg(@x), #0()) -> c_56() :50
-->_1 #compare^#(#0(), #s(@y)) -> c_55() :49
-->_1 #compare^#(#0(), #pos(@y)) -> c_54() :48
-->_1 #compare^#(#0(), #neg(@y)) -> c_53() :47
-->_1 #compare^#(#0(), #0()) -> c_52() :46
52: #compare^#(#neg(@x), #pos(@y)) -> c_58()
53: #compare^#(#pos(@x), #0()) -> c_59()
54: #compare^#(#pos(@x), #neg(@y)) -> c_60()
55: #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y)
-->_1 #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y) :57
-->_1 #compare^#(#s(@x), #0()) -> c_62() :56
-->_1 #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y) :55
-->_1 #compare^#(#pos(@x), #neg(@y)) -> c_60() :54
-->_1 #compare^#(#pos(@x), #0()) -> c_59() :53
-->_1 #compare^#(#neg(@x), #pos(@y)) -> c_58() :52
-->_1 #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x) :51
-->_1 #compare^#(#neg(@x), #0()) -> c_56() :50
-->_1 #compare^#(#0(), #s(@y)) -> c_55() :49
-->_1 #compare^#(#0(), #pos(@y)) -> c_54() :48
-->_1 #compare^#(#0(), #neg(@y)) -> c_53() :47
-->_1 #compare^#(#0(), #0()) -> c_52() :46
56: #compare^#(#s(@x), #0()) -> c_62()
57: #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y)
-->_1 #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y) :57
-->_1 #compare^#(#s(@x), #0()) -> c_62() :56
-->_1 #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y) :55
-->_1 #compare^#(#pos(@x), #neg(@y)) -> c_60() :54
-->_1 #compare^#(#pos(@x), #0()) -> c_59() :53
-->_1 #compare^#(#neg(@x), #pos(@y)) -> c_58() :52
-->_1 #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x) :51
-->_1 #compare^#(#neg(@x), #0()) -> c_56() :50
-->_1 #compare^#(#0(), #s(@y)) -> c_55() :49
-->_1 #compare^#(#0(), #pos(@y)) -> c_54() :48
-->_1 #compare^#(#0(), #neg(@y)) -> c_53() :47
-->_1 #compare^#(#0(), #0()) -> c_52() :46
58: append#1^#(nil(), @ys) -> c_5()
59: insert#2^#(nil(), @keyX, @valX, @x) -> c_9()
60: insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) -> c_12()
61: quicksort#1^#(nil()) -> c_15()
62: splitqs#1^#(nil(), @pivot) -> c_27()
63: sortAll#1^#(nil()) -> c_20()
64: split#1^#(nil()) -> c_24()
65: splitqs#3^#(#false(), @ls, @rs, @x) -> c_29()
66: splitqs#3^#(#true(), @ls, @rs, @x) -> c_30()
67: #and^#(#false(), #false()) -> c_67()
68: #and^#(#false(), #true()) -> c_68()
69: #and^#(#true(), #false()) -> c_69()
70: #and^#(#true(), #true()) -> c_70()
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {19} and add Pre({19}) = {12} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX))
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_14(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_17(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_21(quicksort^#(@vals), sortAll^#(@xs))
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_23(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> c_25(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ #equal^#(@x, @y) -> #eq^#(@x, @y)
, #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, #eq^#(::(@x_1, @x_2), nil()) -> c_32()
, #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33()
, #eq^#(nil(), ::(@y_1, @y_2)) -> c_34()
, #eq^#(nil(), nil()) -> c_35()
, #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36()
, #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37()
, #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38()
, #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, #eq^#(#0(), #0()) -> c_40()
, #eq^#(#0(), #neg(@y)) -> c_41()
, #eq^#(#0(), #pos(@y)) -> c_42()
, #eq^#(#0(), #s(@y)) -> c_43()
, #eq^#(#neg(@x), #0()) -> c_44()
, #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y)
, #eq^#(#neg(@x), #pos(@y)) -> c_46()
, #eq^#(#pos(@x), #0()) -> c_47()
, #eq^#(#pos(@x), #neg(@y)) -> c_48()
, #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y)
, #eq^#(#s(@x), #0()) -> c_50()
, #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y)
, #greater^#(@x, @y) ->
c_2(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y))
, #ckgt^#(#EQ()) -> c_64()
, #ckgt^#(#GT()) -> c_65()
, #ckgt^#(#LT()) -> c_66()
, #compare^#(#0(), #0()) -> c_52()
, #compare^#(#0(), #neg(@y)) -> c_53()
, #compare^#(#0(), #pos(@y)) -> c_54()
, #compare^#(#0(), #s(@y)) -> c_55()
, #compare^#(#neg(@x), #0()) -> c_56()
, #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x)
, #compare^#(#neg(@x), #pos(@y)) -> c_58()
, #compare^#(#pos(@x), #0()) -> c_59()
, #compare^#(#pos(@x), #neg(@y)) -> c_60()
, #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y)
, #compare^#(#s(@x), #0()) -> c_62()
, #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y)
, append#1^#(nil(), @ys) -> c_5()
, insert#2^#(nil(), @keyX, @valX, @x) -> c_9()
, insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) -> c_12()
, quicksort#1^#(nil()) -> c_15()
, splitqs#1^#(nil(), @pivot) -> c_27()
, sortAll#1^#(nil()) -> c_20()
, split#1^#(nil()) -> c_24()
, splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
#greater^#(@x, @pivot))
, splitqs#3^#(#false(), @ls, @rs, @x) -> c_29()
, splitqs#3^#(#true(), @ls, @rs, @x) -> c_30()
, #and^#(#false(), #false()) -> c_67()
, #and^#(#false(), #true()) -> c_68()
, #and^#(#true(), #false()) -> c_69()
, #and^#(#true(), #true()) -> c_70() }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the the dependency graph
->1:{18}
|
|->4:{13,15,14}
| |
| |->6:{8,10,9}
| | |
| | |->52:{1,2}
| | | |
| | | `->53:{57} Weak SCC
| | |
| | |->8:{11,12}
| | | |
| | | |->9:{61} Weak SCC
| | | |
| | | `->10:{64} Weak SCC
| | | |
| | | |->11:{41} Weak SCC
| | | | |
| | | | |->12:{42} Weak SCC
| | | | |
| | | | |->13:{43} Weak SCC
| | | | |
| | | | |->14:{44} Weak SCC
| | | | |
| | | | |->16:{45} Weak SCC
| | | | |
| | | | |->17:{46} Weak SCC
| | | | |
| | | | |->18:{47} Weak SCC
| | | | |
| | | | |->19:{48} Weak SCC
| | | | |
| | | | |->20:{49} Weak SCC
| | | | |
| | | | |->21:{51} Weak SCC
| | | | |
| | | | |->22:{52} Weak SCC
| | | | |
| | | | |->23:{53} Weak SCC
| | | | |
| | | | |->24:{55} Weak SCC
| | | | |
| | | | `->15:{56,54,50} Weak SCC
| | | | |
| | | | |->16:{45} Weak SCC
| | | | |
| | | | |->17:{46} Weak SCC
| | | | |
| | | | |->18:{47} Weak SCC
| | | | |
| | | | |->19:{48} Weak SCC
| | | | |
| | | | |->20:{49} Weak SCC
| | | | |
| | | | |->21:{51} Weak SCC
| | | | |
| | | | |->22:{52} Weak SCC
| | | | |
| | | | |->23:{53} Weak SCC
| | | | |
| | | | `->24:{55} Weak SCC
| | | |
| | | |->25:{65} Weak SCC
| | | |
| | | `->26:{66} Weak SCC
| | |
| | `->7:{60} Weak SCC
| |
| `->5:{62} Weak SCC
|
`->2:{16,17}
|
|->27:{3,7,6,5,4}
| |
| |->30:{19} Weak SCC
| | |
| | |->32:{21} Weak SCC
| | |
| | |->33:{22} Weak SCC
| | |
| | |->34:{23} Weak SCC
| | |
| | |->35:{24} Weak SCC
| | |
| | |->36:{25} Weak SCC
| | |
| | |->37:{26} Weak SCC
| | |
| | |->38:{27} Weak SCC
| | |
| | |->43:{29} Weak SCC
| | |
| | |->44:{30} Weak SCC
| | |
| | |->45:{31} Weak SCC
| | |
| | |->46:{32} Weak SCC
| | |
| | |->47:{33} Weak SCC
| | |
| | |->48:{35} Weak SCC
| | |
| | |->49:{36} Weak SCC
| | |
| | |->50:{37} Weak SCC
| | |
| | |->51:{39} Weak SCC
| | |
| | `->31:{40,38,34,28,20} Weak SCC
| | |
| | |->32:{21} Weak SCC
| | |
| | |->33:{22} Weak SCC
| | |
| | |->34:{23} Weak SCC
| | |
| | |->35:{24} Weak SCC
| | |
| | |->36:{25} Weak SCC
| | |
| | |->37:{26} Weak SCC
| | |
| | |->38:{27} Weak SCC
| | |
| | |->43:{29} Weak SCC
| | |
| | |->44:{30} Weak SCC
| | |
| | |->45:{31} Weak SCC
| | |
| | |->46:{32} Weak SCC
| | |
| | |->47:{33} Weak SCC
| | |
| | |->48:{35} Weak SCC
| | |
| | |->49:{36} Weak SCC
| | |
| | |->50:{37} Weak SCC
| | |
| | |->51:{39} Weak SCC
| | |
| | |->39:{67} Weak SCC
| | |
| | |->40:{68} Weak SCC
| | |
| | |->41:{69} Weak SCC
| | |
| | `->42:{70} Weak SCC
| |
| |->28:{58} Weak SCC
| |
| `->29:{59} Weak SCC
|
`->3:{63} Weak SCC
Here dependency-pairs are as follows:
Strict DPs:
{ 1: append^#(@l, @ys) -> append#1^#(@l, @ys)
, 2: append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, 3: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, 4: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, 5: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, 6: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX))
, 7: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, 8: quicksort^#(@l) -> quicksort#1^#(@l)
, 9: quicksort#1^#(::(@z, @zs)) ->
c_14(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, 10: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_17(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, 11: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, 12: splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs))
, 13: sortAll^#(@l) -> sortAll#1^#(@l)
, 14: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, 15: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_21(quicksort^#(@vals), sortAll^#(@xs))
, 16: split^#(@l) -> split#1^#(@l)
, 17: split#1^#(::(@x, @xs)) ->
c_23(insert^#(@x, split(@xs)), split^#(@xs))
, 18: splitAndSort^#(@l) ->
c_25(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ 19: #equal^#(@x, @y) -> #eq^#(@x, @y)
, 20: #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, 21: #eq^#(::(@x_1, @x_2), nil()) -> c_32()
, 22: #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33()
, 23: #eq^#(nil(), ::(@y_1, @y_2)) -> c_34()
, 24: #eq^#(nil(), nil()) -> c_35()
, 25: #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36()
, 26: #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37()
, 27: #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38()
, 28: #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, 29: #eq^#(#0(), #0()) -> c_40()
, 30: #eq^#(#0(), #neg(@y)) -> c_41()
, 31: #eq^#(#0(), #pos(@y)) -> c_42()
, 32: #eq^#(#0(), #s(@y)) -> c_43()
, 33: #eq^#(#neg(@x), #0()) -> c_44()
, 34: #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y)
, 35: #eq^#(#neg(@x), #pos(@y)) -> c_46()
, 36: #eq^#(#pos(@x), #0()) -> c_47()
, 37: #eq^#(#pos(@x), #neg(@y)) -> c_48()
, 38: #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y)
, 39: #eq^#(#s(@x), #0()) -> c_50()
, 40: #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y)
, 41: #greater^#(@x, @y) ->
c_2(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y))
, 42: #ckgt^#(#EQ()) -> c_64()
, 43: #ckgt^#(#GT()) -> c_65()
, 44: #ckgt^#(#LT()) -> c_66()
, 45: #compare^#(#0(), #0()) -> c_52()
, 46: #compare^#(#0(), #neg(@y)) -> c_53()
, 47: #compare^#(#0(), #pos(@y)) -> c_54()
, 48: #compare^#(#0(), #s(@y)) -> c_55()
, 49: #compare^#(#neg(@x), #0()) -> c_56()
, 50: #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x)
, 51: #compare^#(#neg(@x), #pos(@y)) -> c_58()
, 52: #compare^#(#pos(@x), #0()) -> c_59()
, 53: #compare^#(#pos(@x), #neg(@y)) -> c_60()
, 54: #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y)
, 55: #compare^#(#s(@x), #0()) -> c_62()
, 56: #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y)
, 57: append#1^#(nil(), @ys) -> c_5()
, 58: insert#2^#(nil(), @keyX, @valX, @x) -> c_9()
, 59: insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) -> c_12()
, 60: quicksort#1^#(nil()) -> c_15()
, 61: splitqs#1^#(nil(), @pivot) -> c_27()
, 62: sortAll#1^#(nil()) -> c_20()
, 63: split#1^#(nil()) -> c_24()
, 64: splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
#greater^#(@x, @pivot))
, 65: splitqs#3^#(#false(), @ls, @rs, @x) -> c_29()
, 66: splitqs#3^#(#true(), @ls, @rs, @x) -> c_30()
, 67: #and^#(#false(), #false()) -> c_67()
, 68: #and^#(#false(), #true()) -> c_68()
, 69: #and^#(#true(), #false()) -> c_69()
, 70: #and^#(#true(), #true()) -> c_70() }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 63: split#1^#(nil()) -> c_24()
, 62: sortAll#1^#(nil()) -> c_20()
, 60: quicksort#1^#(nil()) -> c_15()
, 61: splitqs#1^#(nil(), @pivot) -> c_27()
, 64: splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
#greater^#(@x, @pivot))
, 41: #greater^#(@x, @y) ->
c_2(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y))
, 42: #ckgt^#(#EQ()) -> c_64()
, 43: #ckgt^#(#GT()) -> c_65()
, 44: #ckgt^#(#LT()) -> c_66()
, 56: #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y)
, 54: #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y)
, 50: #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x)
, 45: #compare^#(#0(), #0()) -> c_52()
, 46: #compare^#(#0(), #neg(@y)) -> c_53()
, 47: #compare^#(#0(), #pos(@y)) -> c_54()
, 48: #compare^#(#0(), #s(@y)) -> c_55()
, 49: #compare^#(#neg(@x), #0()) -> c_56()
, 51: #compare^#(#neg(@x), #pos(@y)) -> c_58()
, 52: #compare^#(#pos(@x), #0()) -> c_59()
, 53: #compare^#(#pos(@x), #neg(@y)) -> c_60()
, 55: #compare^#(#s(@x), #0()) -> c_62()
, 65: splitqs#3^#(#false(), @ls, @rs, @x) -> c_29()
, 66: splitqs#3^#(#true(), @ls, @rs, @x) -> c_30()
, 58: insert#2^#(nil(), @keyX, @valX, @x) -> c_9()
, 59: insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) -> c_12()
, 19: #equal^#(@x, @y) -> #eq^#(@x, @y)
, 40: #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y)
, 38: #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y)
, 34: #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y)
, 28: #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, 20: #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, 21: #eq^#(::(@x_1, @x_2), nil()) -> c_32()
, 22: #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33()
, 23: #eq^#(nil(), ::(@y_1, @y_2)) -> c_34()
, 24: #eq^#(nil(), nil()) -> c_35()
, 25: #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36()
, 26: #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37()
, 27: #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38()
, 67: #and^#(#false(), #false()) -> c_67()
, 68: #and^#(#false(), #true()) -> c_68()
, 69: #and^#(#true(), #false()) -> c_69()
, 70: #and^#(#true(), #true()) -> c_70()
, 29: #eq^#(#0(), #0()) -> c_40()
, 30: #eq^#(#0(), #neg(@y)) -> c_41()
, 31: #eq^#(#0(), #pos(@y)) -> c_42()
, 32: #eq^#(#0(), #s(@y)) -> c_43()
, 33: #eq^#(#neg(@x), #0()) -> c_44()
, 35: #eq^#(#neg(@x), #pos(@y)) -> c_46()
, 36: #eq^#(#pos(@x), #0()) -> c_47()
, 37: #eq^#(#pos(@x), #neg(@y)) -> c_48()
, 39: #eq^#(#s(@x), #0()) -> c_50()
, 57: append#1^#(nil(), @ys) -> c_5() }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX))
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_14(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_17(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_21(quicksort^#(@vals), sortAll^#(@xs))
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_23(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> c_25(sortAll^#(split(@l)), split^#(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the following dependency-graph
1: append^#(@l, @ys) -> append#1^#(@l, @ys)
-->_1 append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys) :2
2: append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
3: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
-->_1 insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x) :4
4: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
-->_1 insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x) :5
5: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
-->_1 insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX)) :6
6: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX))
-->_1 insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) :7
7: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :3
8: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_14(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :9
9: quicksort#1^#(::(@z, @zs)) ->
c_14(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :11
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_17(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :10
10: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_17(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :8
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :8
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
11: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
-->_1 splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs)) :12
12: splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs))
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :11
13: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :14
14: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_21(quicksort^#(@vals), sortAll^#(@xs)) :15
15: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_21(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :13
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :8
16: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) ->
c_23(insert^#(@x, split(@xs)), split^#(@xs)) :17
17: split#1^#(::(@x, @xs)) ->
c_23(insert^#(@x, split(@xs)), split^#(@xs))
-->_2 split^#(@l) -> split#1^#(@l) :16
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :3
18: splitAndSort^#(@l) -> c_25(sortAll^#(split(@l)), split^#(@l))
-->_2 split^#(@l) -> split#1^#(@l) :16
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :13
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX))
, splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We employ 'linear path analysis' using the following approximated
dependency graph:
->1:{18} [ ? ]
|
|->3:{13,15,14} [ ? ]
| |
| `->4:{8,10,9} [ ? ]
| |
| |->7:{1,2} [ MAYBE ]
| |
| `->5:{11,12} [ YES(O(1),O(n^3)) ]
|
`->2:{16,17} [ ? ]
|
`->6:{3,7,6,5,4} [ YES(O(1),O(n^2)) ]
Here dependency-pairs are as follows:
Strict DPs:
{ 1: append^#(@l, @ys) -> append#1^#(@l, @ys)
, 2: append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, 3: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, 4: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, 5: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, 6: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, 7: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, 8: quicksort^#(@l) -> quicksort#1^#(@l)
, 9: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, 10: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, 11: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, 12: splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, 13: sortAll^#(@l) -> sortAll#1^#(@l)
, 14: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, 15: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, 16: split^#(@l) -> split#1^#(@l)
, 17: split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
, 18: splitAndSort^#(@l) ->
c_5(sortAll^#(split(@l)), split^#(@l)) }
* Path 1:{18}->3:{13,15,14}->4:{8,10,9}->7:{1,2}: MAYBE
-----------------------------------------------------
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append^#(@l, @ys) -> append#1^#(@l, @ys)
-->_1 append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys) :2
2: append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
3: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :4
4: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :5
5: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :3
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :3
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
6: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :7
7: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :8
8: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :6
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :3
9: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :6
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs: { append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append^#(@l, @ys) -> append#1^#(@l, @ys)
-->_1 append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys) :9
2: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :3
3: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :4
4: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :2
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :2
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
5: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :6
6: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :7
7: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :5
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :2
8: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :5
9: append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {4} and add Pre({4}) = {3} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append^#(@l, @ys) -> append#1^#(@l, @ys)
-->_1 append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys) :8
2: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :3
3: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :9
4: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :5
5: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :6
6: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :4
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :2
7: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :4
8: append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
9: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :2
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :2
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append^#(@l, @ys) -> append#1^#(@l, @ys)
-->_1 append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys) :7
2: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :8
3: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :4
4: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :5
5: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :3
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :2
6: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :3
7: append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
8: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :9
9: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :2
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :2
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {5} and add Pre({5}) = {4} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append^#(@l, @ys) -> append#1^#(@l, @ys)
-->_1 append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys) :6
2: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :7
3: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :4
4: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :9
5: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :3
6: append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
7: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :8
8: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :2
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :2
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
9: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :3
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :2
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {4} and add Pre({4}) = {3} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l)
, sortAll^#(@l) -> sortAll#1^#(@l)
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append^#(@l, @ys) -> append#1^#(@l, @ys)
-->_1 append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys) :5
2: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :6
3: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :8
4: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :3
5: append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
6: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :7
7: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :2
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :2
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
8: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :9
9: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :3
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :2
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {4} and add Pre({4}) = {} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l)
, sortAll^#(@l) -> sortAll#1^#(@l) }
Weak DPs:
{ append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the following dependency-graph
1: append^#(@l, @ys) -> append#1^#(@l, @ys)
-->_1 append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys) :4
2: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :5
3: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :7
4: append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
5: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :6
6: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :2
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :2
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
7: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :8
8: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :3
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :2
9: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :3
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l)
, sortAll^#(@l) -> sortAll#1^#(@l) }
Weak DPs:
{ append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_2(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l)
, sortAll^#(@l) -> sortAll#1^#(@l) }
Weak DPs:
{ append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_2(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
None of the processors succeeded.
Details of failed attempt(s):
-----------------------------
1) 'empty' failed due to the following reason:
Empty strict component of the problem is NOT empty.
2) 'With Problem ...' failed due to the following reason:
We measure the number of applications of following selected rules
relative to the remaining rules.
Selected Rules (A):
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) }
Remaining Rules (B):
{ sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_2(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
The length of a single A-subderivation is expressed by the
following problem.
Problem (A):
------------
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l) }
Weak DPs:
{ append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
The number of B-applications is expressed by the following problem.
Problem (B):
------------
Strict DPs:
{ sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_2(quicksort^#(@vals), sortAll^#(@xs)) }
Weak DPs:
{ sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
TcT answers on problem (B) 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:
{ sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_2(quicksort^#(@vals), sortAll^#(@xs)) }
Weak DPs:
{ sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the following dependency-graph
1: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :3
2: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_2(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :1
3: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_2(quicksort^#(@vals), sortAll^#(@xs)) :2
4: splitAndSort^#(@l) -> sortAll^#(split(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_2(quicksort^#(@vals), sortAll^#(@xs)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs) }
Weak DPs:
{ sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs) }
Weak DPs:
{ sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
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: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, 4: splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Trs:
{ insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split#1(nil()) -> nil() }
Sub-proof:
----------
The following argument positions are usable:
Uargs(#equal) = {}, Uargs(#eq) = {}, Uargs(#greater) = {},
Uargs(#compare) = {}, Uargs(#ckgt) = {}, Uargs(append) = {},
Uargs(append#1) = {}, Uargs(::) = {}, Uargs(insert) = {},
Uargs(insert#1) = {}, Uargs(tuple#2) = {}, Uargs(insert#2) = {},
Uargs(insert#3) = {}, Uargs(insert#4) = {}, Uargs(quicksort) = {},
Uargs(quicksort#1) = {}, Uargs(splitqs) = {},
Uargs(quicksort#2) = {}, Uargs(split) = {}, Uargs(split#1) = {},
Uargs(splitqs#1) = {}, Uargs(splitqs#2) = {},
Uargs(splitqs#3) = {}, Uargs(#and) = {}, Uargs(#neg) = {},
Uargs(#pos) = {}, Uargs(#s) = {}, Uargs(#equal^#) = {},
Uargs(#eq^#) = {}, Uargs(#greater^#) = {}, Uargs(#ckgt^#) = {},
Uargs(#compare^#) = {}, Uargs(append^#) = {},
Uargs(append#1^#) = {}, Uargs(insert^#) = {},
Uargs(insert#1^#) = {}, Uargs(insert#2^#) = {},
Uargs(insert#3^#) = {}, Uargs(insert#4^#) = {},
Uargs(quicksort^#) = {}, Uargs(quicksort#1^#) = {},
Uargs(quicksort#2^#) = {}, Uargs(splitqs^#) = {},
Uargs(splitqs#1^#) = {}, Uargs(sortAll^#) = {},
Uargs(sortAll#1^#) = {}, Uargs(sortAll#2^#) = {},
Uargs(split^#) = {}, Uargs(split#1^#) = {},
Uargs(splitAndSort^#) = {}, Uargs(splitqs#2^#) = {},
Uargs(splitqs#3^#) = {}, Uargs(#and^#) = {}, Uargs(c_2) = {}
TcT has computed following constructor-based matrix interpretation
satisfying not(EDA).
[#equal](x1, x2) = [1]
[#eq](x1, x2) = [1]
[#greater](x1, x2) = [0]
[#compare](x1, x2) = [0]
[#ckgt](x1) = [0]
[append](x1, x2) = [0]
[append#1](x1, x2) = [0]
[::](x1, x2) = [1] x1 + [1] x2 + [1]
[nil] = [1]
[insert](x1, x2) = [1] x2 + [2]
[insert#1](x1, x2, x3) = [1] x2 + [2]
[tuple#2](x1, x2) = [0]
[insert#2](x1, x2, x3, x4) = [1] x1 + [2]
[insert#3](x1, x2, x3, x4, x5) = [1] x3 + [3]
[insert#4](x1, x2, x3, x4, x5, x6) = [2] x1 + [1] x3 + [1]
[#false] = [1]
[#true] = [1]
[quicksort](x1) = [0]
[quicksort#1](x1) = [0]
[splitqs](x1, x2) = [0]
[quicksort#2](x1, x2) = [0]
[split](x1) = [2] x1 + [1]
[split#1](x1) = [2] x1 + [1]
[splitqs#1](x1, x2) = [0]
[splitqs#2](x1, x2, x3) = [0]
[splitqs#3](x1, x2, x3, x4) = [0]
[#and](x1, x2) = [1] x1 + [0]
[#EQ] = [0]
[#GT] = [0]
[#LT] = [0]
[#0] = [0]
[#neg](x1) = [1] x1 + [0]
[#pos](x1) = [1] x1 + [0]
[#s](x1) = [1] x1 + [0]
[#equal^#](x1, x2) = [0]
[#eq^#](x1, x2) = [0]
[#greater^#](x1, x2) = [0]
[#ckgt^#](x1) = [0]
[#compare^#](x1, x2) = [0]
[append^#](x1, x2) = [0]
[append#1^#](x1, x2) = [0]
[insert^#](x1, x2) = [0]
[insert#1^#](x1, x2, x3) = [0]
[insert#2^#](x1, x2, x3, x4) = [0]
[insert#3^#](x1, x2, x3, x4, x5) = [0]
[insert#4^#](x1, x2, x3, x4, x5, x6) = [0]
[quicksort^#](x1) = [0]
[quicksort#1^#](x1) = [0]
[quicksort#2^#](x1, x2) = [0]
[splitqs^#](x1, x2) = [0]
[splitqs#1^#](x1, x2) = [0]
[sortAll^#](x1) = [1] x1 + [1]
[sortAll#1^#](x1) = [1] x1 + [1]
[sortAll#2^#](x1, x2) = [1] x2 + [2]
[split^#](x1) = [0]
[split#1^#](x1) = [0]
[splitAndSort^#](x1) = [3] x1 + [3]
[splitqs#2^#](x1, x2, x3) = [0]
[splitqs#3^#](x1, x2, x3, x4) = [0]
[#and^#](x1, x2) = [0]
[c_2](x1, x2) = [0]
[c] = [0]
This order satisfies following ordering constraints
[#equal(@x, @y)] = [1]
>= [1]
= [#eq(@x, @y)]
[#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [1]
>= [1]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(::(@x_1, @x_2), nil())] = [1]
>= [1]
= [#false()]
[#eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2))] = [1]
>= [1]
= [#false()]
[#eq(nil(), ::(@y_1, @y_2))] = [1]
>= [1]
= [#false()]
[#eq(nil(), nil())] = [1]
>= [1]
= [#true()]
[#eq(nil(), tuple#2(@y_1, @y_2))] = [1]
>= [1]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2))] = [1]
>= [1]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), nil())] = [1]
>= [1]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2))] = [1]
>= [1]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(#0(), #0())] = [1]
>= [1]
= [#true()]
[#eq(#0(), #neg(@y))] = [1]
>= [1]
= [#false()]
[#eq(#0(), #pos(@y))] = [1]
>= [1]
= [#false()]
[#eq(#0(), #s(@y))] = [1]
>= [1]
= [#false()]
[#eq(#neg(@x), #0())] = [1]
>= [1]
= [#false()]
[#eq(#neg(@x), #neg(@y))] = [1]
>= [1]
= [#eq(@x, @y)]
[#eq(#neg(@x), #pos(@y))] = [1]
>= [1]
= [#false()]
[#eq(#pos(@x), #0())] = [1]
>= [1]
= [#false()]
[#eq(#pos(@x), #neg(@y))] = [1]
>= [1]
= [#false()]
[#eq(#pos(@x), #pos(@y))] = [1]
>= [1]
= [#eq(@x, @y)]
[#eq(#s(@x), #0())] = [1]
>= [1]
= [#false()]
[#eq(#s(@x), #s(@y))] = [1]
>= [1]
= [#eq(@x, @y)]
[insert(@x, @l)] = [1] @l + [2]
>= [1] @l + [2]
= [insert#1(@x, @l, @x)]
[insert#1(tuple#2(@valX, @keyX), @l, @x)] = [1] @l + [2]
>= [1] @l + [2]
= [insert#2(@l, @keyX, @valX, @x)]
[insert#2(::(@l1, @ls), @keyX, @valX, @x)] = [1] @l1 + [1] @ls + [3]
>= [1] @ls + [3]
= [insert#3(@l1, @keyX, @ls, @valX, @x)]
[insert#2(nil(), @keyX, @valX, @x)] = [3]
> [2]
= [::(tuple#2(::(@valX, nil()), @keyX), nil())]
[insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x)] = [1] @ls + [3]
>= [1] @ls + [3]
= [insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)]
[insert#4(#false(), @key1, @ls, @valX, @vals1, @x)] = [1] @ls + [3]
>= [1] @ls + [3]
= [::(tuple#2(@vals1, @key1), insert(@x, @ls))]
[insert#4(#true(), @key1, @ls, @valX, @vals1, @x)] = [1] @ls + [3]
> [1] @ls + [1]
= [::(tuple#2(::(@valX, @vals1), @key1), @ls)]
[split(@l)] = [2] @l + [1]
>= [2] @l + [1]
= [split#1(@l)]
[split#1(::(@x, @xs))] = [2] @x + [2] @xs + [3]
>= [2] @xs + [3]
= [insert(@x, split(@xs))]
[split#1(nil())] = [3]
> [1]
= [nil()]
[#and(#false(), #false())] = [1]
>= [1]
= [#false()]
[#and(#false(), #true())] = [1]
>= [1]
= [#false()]
[#and(#true(), #false())] = [1]
>= [1]
= [#false()]
[#and(#true(), #true())] = [1]
>= [1]
= [#true()]
[sortAll^#(@l)] = [1] @l + [1]
>= [1] @l + [1]
= [sortAll#1^#(@l)]
[sortAll#1^#(::(@x, @xs))] = [1] @x + [1] @xs + [2]
>= [1] @xs + [2]
= [sortAll#2^#(@x, @xs)]
[sortAll#2^#(tuple#2(@vals, @key), @xs)] = [1] @xs + [2]
> [1] @xs + [1]
= [sortAll^#(@xs)]
[splitAndSort^#(@l)] = [3] @l + [3]
> [2] @l + [2]
= [sortAll^#(split(@l))]
Processor 'matrix interpretation of dimension 1' induces the
complexity certificate YES(?,O(n^1)) on application of rules {2,4}.
Here rules are labeled according to the (estimated) dependency
graph
1: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :3
2: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :1
3: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs) :2
4: splitAndSort^#(@l) -> sortAll^#(split(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :1
- The rules {2,4} have known complexity. These cover all
predecessors of {1}, their complexity is equally bounded.
- The rules {1,2,4} have known complexity. These cover all
predecessors of {3}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules
{1,2,3,4} is given by YES(?,O(n^1)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{4} Weak SCC
|
`->2:{1,3,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: sortAll^#(@l) -> sortAll#1^#(@l)
, 2: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, 3: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, 4: splitAndSort^#(@l) -> sortAll^#(split(@l)) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 4: splitAndSort^#(@l) -> sortAll^#(split(@l))
, 1: sortAll^#(@l) -> sortAll#1^#(@l)
, 3: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, 2: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) }
We apply the transformation 'usablerules' on the sub-problem:
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
No rule is usable.
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
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 are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l) }
Weak DPs:
{ append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We measure the number of applications of following selected rules
relative to the remaining rules.
Selected Rules (A):
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys) }
Remaining Rules (B):
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
The length of a single A-subderivation is expressed by the
following problem.
Problem (A):
------------
Strict DPs: { append^#(@l, @ys) -> append#1^#(@l, @ys) }
Weak DPs:
{ append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
append^#(quicksort(@xs), ::(@z, quicksort(@ys)))
, quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs)
, quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
The number of B-applications is expressed by the following problem.
Problem (B):
------------
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
TcT answers on problem (B) 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:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the following dependency-graph
1: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z) :3
2: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :1
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :1
3: quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z)
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :2
4: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :5
5: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs) :7
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
quicksort^#(@vals) :6
6: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
7: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :4
8: splitAndSort^#(@l) -> sortAll^#(split(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :4
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys)) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys)) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
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: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys))
, 6: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, 8: splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Trs:
{ #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#s(@x), #0()) -> #false()
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split#1(nil()) -> nil()
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil()) }
Sub-proof:
----------
The following argument positions are usable:
Uargs(#equal) = {}, Uargs(#eq) = {}, Uargs(#greater) = {},
Uargs(#compare) = {}, Uargs(#ckgt) = {}, Uargs(append) = {},
Uargs(append#1) = {}, Uargs(::) = {}, Uargs(insert) = {},
Uargs(insert#1) = {}, Uargs(tuple#2) = {}, Uargs(insert#2) = {},
Uargs(insert#3) = {}, Uargs(insert#4) = {}, Uargs(quicksort) = {},
Uargs(quicksort#1) = {}, Uargs(splitqs) = {},
Uargs(quicksort#2) = {}, Uargs(split) = {}, Uargs(split#1) = {},
Uargs(splitqs#1) = {}, Uargs(splitqs#2) = {},
Uargs(splitqs#3) = {}, Uargs(#and) = {}, Uargs(#neg) = {},
Uargs(#pos) = {}, Uargs(#s) = {}, Uargs(#equal^#) = {},
Uargs(#eq^#) = {}, Uargs(#greater^#) = {}, Uargs(#ckgt^#) = {},
Uargs(#compare^#) = {}, Uargs(append^#) = {},
Uargs(append#1^#) = {}, Uargs(insert^#) = {},
Uargs(insert#1^#) = {}, Uargs(insert#2^#) = {},
Uargs(insert#3^#) = {}, Uargs(insert#4^#) = {},
Uargs(quicksort^#) = {}, Uargs(quicksort#1^#) = {},
Uargs(quicksort#2^#) = {}, Uargs(splitqs^#) = {},
Uargs(splitqs#1^#) = {}, Uargs(sortAll^#) = {},
Uargs(sortAll#1^#) = {}, Uargs(sortAll#2^#) = {},
Uargs(split^#) = {}, Uargs(split#1^#) = {},
Uargs(splitAndSort^#) = {}, Uargs(splitqs#2^#) = {},
Uargs(splitqs#3^#) = {}, Uargs(#and^#) = {}, Uargs(c_1) = {},
Uargs(c_1) = {1, 2}
TcT has computed following constructor-based matrix interpretation
satisfying not(EDA) and not(IDA(1)).
[#equal](x1, x2) = [0 0] x1 + [3 0] x2 + [3]
[1 3] [2 0] [3]
[#eq](x1, x2) = [3]
[3]
[#greater](x1, x2) = [0 0] x1 + [0 0] x2 + [0]
[0 2] [0 2] [1]
[#compare](x1, x2) = [0 1] x1 + [0 1] x2 + [1]
[0 1] [0 1] [0]
[#ckgt](x1) = [0 0] x1 + [0]
[1 1] [0]
[append](x1, x2) = [0]
[0]
[append#1](x1, x2) = [0]
[0]
[::](x1, x2) = [0 2] x1 + [1 0] x2 + [0]
[0 0] [0 1] [1]
[nil] = [3]
[0]
[insert](x1, x2) = [1 0] x2 + [3]
[0 1] [1]
[insert#1](x1, x2, x3) = [1 0] x2 + [3]
[0 1] [1]
[tuple#2](x1, x2) = [0 2] x1 + [0 2] x2 + [1]
[0 1] [0 0] [0]
[insert#2](x1, x2, x3, x4) = [1 0] x1 + [3]
[0 1] [1]
[insert#3](x1, x2, x3, x4, x5) = [0 2] x1 + [1 0] x3 + [3]
[0 0] [0 1] [2]
[insert#4](x1, x2, x3, x4, x5, x6) = [1 0] x3 + [0 2] x5 + [3]
[0 1] [0 0] [2]
[#false] = [0]
[3]
[#true] = [0]
[1]
[quicksort](x1) = [0]
[0]
[quicksort#1](x1) = [0]
[0]
[splitqs](x1, x2) = [0 0] x1 + [0 2] x2 + [2]
[0 2] [1 2] [1]
[quicksort#2](x1, x2) = [0]
[0]
[split](x1) = [1 3] x1 + [1]
[1 1] [3]
[split#1](x1) = [1 3] x1 + [1]
[1 1] [3]
[splitqs#1](x1, x2) = [0 2] x1 + [0 0] x2 + [2]
[1 2] [0 2] [0]
[splitqs#2](x1, x2, x3) = [1 0] x1 + [0 0] x2 + [0
0] x3 + [2]
[1 0] [0 2] [0
2] [0]
[splitqs#3](x1, x2, x3, x4) = [2 0] x1 + [0 2] x2 + [0
2] x3 + [3]
[1 1] [0 1] [0
2] [0]
[#and](x1, x2) = [0]
[3]
[#EQ] = [1]
[2]
[#GT] = [1]
[0]
[#LT] = [2]
[1]
[#0] = [1]
[2]
[#neg](x1) = [1 0] x1 + [0]
[0 1] [2]
[#pos](x1) = [0 1] x1 + [1]
[0 1] [2]
[#s](x1) = [1 0] x1 + [0]
[0 1] [0]
[#equal^#](x1, x2) = [0]
[0]
[#eq^#](x1, x2) = [0]
[0]
[#greater^#](x1, x2) = [0]
[0]
[#ckgt^#](x1) = [0]
[0]
[#compare^#](x1, x2) = [0]
[0]
[append^#](x1, x2) = [0]
[0]
[append#1^#](x1, x2) = [0]
[0]
[insert^#](x1, x2) = [0]
[0]
[insert#1^#](x1, x2, x3) = [0]
[0]
[insert#2^#](x1, x2, x3, x4) = [0]
[0]
[insert#3^#](x1, x2, x3, x4, x5) = [0]
[0]
[insert#4^#](x1, x2, x3, x4, x5, x6) = [0]
[0]
[quicksort^#](x1) = [0 2] x1 + [0]
[0 0] [0]
[quicksort#1^#](x1) = [0 2] x1 + [0]
[0 0] [0]
[quicksort#2^#](x1, x2) = [1 0] x1 + [0]
[0 0] [0]
[splitqs^#](x1, x2) = [0]
[0]
[splitqs#1^#](x1, x2) = [0]
[0]
[sortAll^#](x1) = [1 0] x1 + [1]
[0 0] [0]
[sortAll#1^#](x1) = [1 0] x1 + [1]
[0 0] [0]
[sortAll#2^#](x1, x2) = [0 2] x1 + [1 0] x2 + [1]
[0 0] [0 0] [0]
[split^#](x1) = [0]
[0]
[split#1^#](x1) = [0]
[0]
[splitAndSort^#](x1) = [3 3] x1 + [3]
[3 3] [3]
[splitqs#2^#](x1, x2, x3) = [0]
[0]
[splitqs#3^#](x1, x2, x3, x4) = [0]
[0]
[#and^#](x1, x2) = [0]
[0]
[c_1](x1, x2, x3) = [0]
[0]
[c] = [0]
[0]
[c_1](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
[0 0] [0 0] [0]
This order satisfies following ordering constraints
[#equal(@x, @y)] = [0 0] @x + [3 0] @y + [3]
[1 3] [2 0] [3]
>= [3]
[3]
= [#eq(@x, @y)]
[#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [3]
[3]
> [0]
[3]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(::(@x_1, @x_2), nil())] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2))] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(nil(), ::(@y_1, @y_2))] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(nil(), nil())] = [3]
[3]
> [0]
[1]
= [#true()]
[#eq(nil(), tuple#2(@y_1, @y_2))] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2))] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), nil())] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2))] = [3]
[3]
> [0]
[3]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(#0(), #0())] = [3]
[3]
> [0]
[1]
= [#true()]
[#eq(#0(), #neg(@y))] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(#0(), #pos(@y))] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(#0(), #s(@y))] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(#neg(@x), #0())] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(#neg(@x), #neg(@y))] = [3]
[3]
>= [3]
[3]
= [#eq(@x, @y)]
[#eq(#neg(@x), #pos(@y))] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(#pos(@x), #0())] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(#pos(@x), #neg(@y))] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(#pos(@x), #pos(@y))] = [3]
[3]
>= [3]
[3]
= [#eq(@x, @y)]
[#eq(#s(@x), #0())] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(#s(@x), #s(@y))] = [3]
[3]
>= [3]
[3]
= [#eq(@x, @y)]
[#greater(@x, @y)] = [0 0] @x + [0 0] @y + [0]
[0 2] [0 2] [1]
>= [0 0] @x + [0 0] @y + [0]
[0 2] [0 2] [1]
= [#ckgt(#compare(@x, @y))]
[#compare(#0(), #0())] = [5]
[4]
> [1]
[2]
= [#EQ()]
[#compare(#0(), #neg(@y))] = [0 1] @y + [5]
[0 1] [4]
> [1]
[0]
= [#GT()]
[#compare(#0(), #pos(@y))] = [0 1] @y + [5]
[0 1] [4]
> [2]
[1]
= [#LT()]
[#compare(#0(), #s(@y))] = [0 1] @y + [3]
[0 1] [2]
> [2]
[1]
= [#LT()]
[#compare(#neg(@x), #0())] = [0 1] @x + [5]
[0 1] [4]
> [2]
[1]
= [#LT()]
[#compare(#neg(@x), #neg(@y))] = [0 1] @x + [0 1] @y + [5]
[0 1] [0 1] [4]
> [0 1] @x + [0 1] @y + [1]
[0 1] [0 1] [0]
= [#compare(@y, @x)]
[#compare(#neg(@x), #pos(@y))] = [0 1] @x + [0 1] @y + [5]
[0 1] [0 1] [4]
> [2]
[1]
= [#LT()]
[#compare(#pos(@x), #0())] = [0 1] @x + [5]
[0 1] [4]
> [1]
[0]
= [#GT()]
[#compare(#pos(@x), #neg(@y))] = [0 1] @x + [0 1] @y + [5]
[0 1] [0 1] [4]
> [1]
[0]
= [#GT()]
[#compare(#pos(@x), #pos(@y))] = [0 1] @x + [0 1] @y + [5]
[0 1] [0 1] [4]
> [0 1] @x + [0 1] @y + [1]
[0 1] [0 1] [0]
= [#compare(@x, @y)]
[#compare(#s(@x), #0())] = [0 1] @x + [3]
[0 1] [2]
> [1]
[0]
= [#GT()]
[#compare(#s(@x), #s(@y))] = [0 1] @x + [0 1] @y + [1]
[0 1] [0 1] [0]
>= [0 1] @x + [0 1] @y + [1]
[0 1] [0 1] [0]
= [#compare(@x, @y)]
[#ckgt(#EQ())] = [0]
[3]
>= [0]
[3]
= [#false()]
[#ckgt(#GT())] = [0]
[1]
>= [0]
[1]
= [#true()]
[#ckgt(#LT())] = [0]
[3]
>= [0]
[3]
= [#false()]
[insert(@x, @l)] = [1 0] @l + [3]
[0 1] [1]
>= [1 0] @l + [3]
[0 1] [1]
= [insert#1(@x, @l, @x)]
[insert#1(tuple#2(@valX, @keyX), @l, @x)] = [1 0] @l + [3]
[0 1] [1]
>= [1 0] @l + [3]
[0 1] [1]
= [insert#2(@l, @keyX, @valX, @x)]
[insert#2(::(@l1, @ls), @keyX, @valX, @x)] = [0 2] @l1 + [1 0] @ls + [3]
[0 0] [0 1] [2]
>= [0 2] @l1 + [1 0] @ls + [3]
[0 0] [0 1] [2]
= [insert#3(@l1, @keyX, @ls, @valX, @x)]
[insert#2(nil(), @keyX, @valX, @x)] = [6]
[1]
> [5]
[1]
= [::(tuple#2(::(@valX, nil()), @keyX), nil())]
[insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x)] = [1 0] @ls + [0 2] @vals1 + [3]
[0 1] [0 0] [2]
>= [1 0] @ls + [0 2] @vals1 + [3]
[0 1] [0 0] [2]
= [insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)]
[insert#4(#false(), @key1, @ls, @valX, @vals1, @x)] = [1 0] @ls + [0 2] @vals1 + [3]
[0 1] [0 0] [2]
>= [1 0] @ls + [0 2] @vals1 + [3]
[0 1] [0 0] [2]
= [::(tuple#2(@vals1, @key1), insert(@x, @ls))]
[insert#4(#true(), @key1, @ls, @valX, @vals1, @x)] = [1 0] @ls + [0 2] @vals1 + [3]
[0 1] [0 0] [2]
> [1 0] @ls + [0 2] @vals1 + [2]
[0 1] [0 0] [1]
= [::(tuple#2(::(@valX, @vals1), @key1), @ls)]
[splitqs(@pivot, @l)] = [0 2] @l + [0 0] @pivot + [2]
[1 2] [0 2] [1]
>= [0 2] @l + [0 0] @pivot + [2]
[1 2] [0 2] [0]
= [splitqs#1(@l, @pivot)]
[split(@l)] = [1 3] @l + [1]
[1 1] [3]
>= [1 3] @l + [1]
[1 1] [3]
= [split#1(@l)]
[split#1(::(@x, @xs))] = [0 2] @x + [1 3] @xs + [4]
[0 2] [1 1] [4]
>= [1 3] @xs + [4]
[1 1] [4]
= [insert(@x, split(@xs))]
[split#1(nil())] = [4]
[6]
> [3]
[0]
= [nil()]
[splitqs#1(::(@x, @xs), @pivot)] = [0 0] @pivot + [0 0] @x + [0 2] @xs + [4]
[0 2] [0 2] [1 2] [2]
>= [0 0] @pivot + [0 0] @x + [0 2] @xs + [4]
[0 2] [0 2] [0 2] [2]
= [splitqs#2(splitqs(@pivot, @xs), @pivot, @x)]
[splitqs#1(nil(), @pivot)] = [0 0] @pivot + [2]
[0 2] [3]
> [1]
[0]
= [tuple#2(nil(), nil())]
[splitqs#2(tuple#2(@ls, @rs), @pivot, @x)] = [0 2] @ls + [0 0] @pivot + [0 2] @rs + [0 0] @x + [3]
[0 2] [0 2] [0 2] [0 2] [1]
>= [0 2] @ls + [0 0] @pivot + [0 2] @rs + [0 0] @x + [3]
[0 1] [0 2] [0 2] [0 2] [1]
= [splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)]
[splitqs#3(#false(), @ls, @rs, @x)] = [0 2] @ls + [0 2] @rs + [3]
[0 1] [0 2] [3]
>= [0 2] @ls + [0 2] @rs + [3]
[0 1] [0 0] [1]
= [tuple#2(::(@x, @ls), @rs)]
[splitqs#3(#true(), @ls, @rs, @x)] = [0 2] @ls + [0 2] @rs + [3]
[0 1] [0 2] [1]
>= [0 2] @ls + [0 2] @rs + [3]
[0 1] [0 0] [0]
= [tuple#2(@ls, ::(@x, @rs))]
[#and(#false(), #false())] = [0]
[3]
>= [0]
[3]
= [#false()]
[#and(#false(), #true())] = [0]
[3]
>= [0]
[3]
= [#false()]
[#and(#true(), #false())] = [0]
[3]
>= [0]
[3]
= [#false()]
[#and(#true(), #true())] = [0]
[3]
>= [0]
[1]
= [#true()]
[quicksort^#(@l)] = [0 2] @l + [0]
[0 0] [0]
>= [0 2] @l + [0]
[0 0] [0]
= [quicksort#1^#(@l)]
[quicksort#1^#(::(@z, @zs))] = [0 2] @zs + [2]
[0 0] [0]
>= [0 2] @zs + [2]
[0 0] [0]
= [quicksort#2^#(splitqs(@z, @zs), @z)]
[quicksort#2^#(tuple#2(@xs, @ys), @z)] = [0 2] @xs + [0 2] @ys + [1]
[0 0] [0 0] [0]
> [0 2] @xs + [0 2] @ys + [0]
[0 0] [0 0] [0]
= [c_1(quicksort^#(@xs), quicksort^#(@ys))]
[sortAll^#(@l)] = [1 0] @l + [1]
[0 0] [0]
>= [1 0] @l + [1]
[0 0] [0]
= [sortAll#1^#(@l)]
[sortAll#1^#(::(@x, @xs))] = [0 2] @x + [1 0] @xs + [1]
[0 0] [0 0] [0]
>= [0 2] @x + [1 0] @xs + [1]
[0 0] [0 0] [0]
= [sortAll#2^#(@x, @xs)]
[sortAll#2^#(tuple#2(@vals, @key), @xs)] = [0 2] @vals + [1 0] @xs + [1]
[0 0] [0 0] [0]
> [0 2] @vals + [0]
[0 0] [0]
= [quicksort^#(@vals)]
[sortAll#2^#(tuple#2(@vals, @key), @xs)] = [0 2] @vals + [1 0] @xs + [1]
[0 0] [0 0] [0]
>= [1 0] @xs + [1]
[0 0] [0]
= [sortAll^#(@xs)]
[splitAndSort^#(@l)] = [3 3] @l + [3]
[3 3] [3]
> [1 3] @l + [2]
[0 0] [0]
= [sortAll^#(split(@l))]
Processor 'matrix interpretation of dimension 2' induces the
complexity certificate YES(?,O(n^1)) on application of rules
{2,6,8}. Here rules are labeled according to the (estimated)
dependency graph
1: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z) :3
2: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys))
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :1
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
3: quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z)
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys)) :2
4: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :5
5: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs) :7
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
quicksort^#(@vals) :6
6: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
7: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :4
8: splitAndSort^#(@l) -> sortAll^#(split(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :4
- The rules {2,6,8} have known complexity. These cover all
predecessors of {1}, their complexity is equally bounded.
- The rules {1,2,6,8} have known complexity. These cover all
predecessors of {3}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules
{1,2,3,6,8} is given by YES(?,O(n^1)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{8} Weak SCC
|
`->2:{4,7,5} Weak SCC
|
`->3:{6} Weak SCC
|
`->4:{1,3,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: quicksort^#(@l) -> quicksort#1^#(@l)
, 2: quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z)
, 3: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys))
, 4: sortAll^#(@l) -> sortAll#1^#(@l)
, 5: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, 6: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, 7: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, 8: splitAndSort^#(@l) -> sortAll^#(split(@l)) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 8: splitAndSort^#(@l) -> sortAll^#(split(@l))
, 4: sortAll^#(@l) -> sortAll#1^#(@l)
, 7: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, 5: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, 6: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, 1: quicksort^#(@l) -> quicksort#1^#(@l)
, 3: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys))
, 2: quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z) }
We apply the transformation 'usablerules' on the sub-problem:
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
No rule is usable.
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
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 are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs: { append^#(@l, @ys) -> append#1^#(@l, @ys) }
Weak DPs:
{ append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
append^#(quicksort(@xs), ::(@z, quicksort(@ys)))
, quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs)
, quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
None of the processors succeeded.
Details of failed attempt(s):
-----------------------------
1) 'empty' failed due to the following reason:
Empty strict component of the problem is NOT empty.
2) 'empty' failed due to the following reason:
Empty strict component of the problem is NOT empty.
* Path 1:{18}->3:{13,15,14}->4:{8,10,9}->5:{11,12}: YES(O(1),O(n^3))
------------------------------------------------------------------
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We consider the (estimated) dependency graph
1: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :2
2: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :4
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :3
3: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :1
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :1
4: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
-->_1 splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) :5
5: splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
-->_1 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :4
6: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :7
7: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :8
8: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :6
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
9: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :6
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {5} and add Pre({5}) = {4} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We consider the (estimated) dependency graph
1: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :2
2: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :4
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :3
3: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :1
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :1
4: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
-->_1 splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) :9
5: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :6
6: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :7
7: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :5
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
8: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :5
9: splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
-->_1 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :4
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We consider the (estimated) dependency graph
1: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :2
2: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :8
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :3
3: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
-->_1 splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) :9
4: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :5
5: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :6
6: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :4
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
7: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :4
8: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :1
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :1
9: splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
-->_1 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :3
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We consider the (estimated) dependency graph
1: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :7
2: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
-->_1 splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) :9
3: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :4
4: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :5
5: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :3
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
6: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :3
7: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :8
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :2
8: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :1
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :1
9: splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
-->_1 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :2
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {5} and add Pre({5}) = {4} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We consider the (estimated) dependency graph
1: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :6
2: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
-->_1 splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) :8
3: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :4
4: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :9
5: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :3
6: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :7
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :2
7: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :1
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :1
8: splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
-->_1 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :2
9: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :3
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {4} and add Pre({4}) = {3} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, sortAll^#(@l) -> sortAll#1^#(@l)
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We consider the (estimated) dependency graph
1: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :5
2: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
-->_1 splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) :7
3: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :8
4: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :3
5: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :6
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :2
6: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :1
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :1
7: splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
-->_1 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :2
8: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :9
9: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :3
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {4} and add Pre({4}) = {} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, sortAll^#(@l) -> sortAll#1^#(@l) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We consider the following dependency-graph
1: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :4
2: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
-->_1 splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) :6
3: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :7
4: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :5
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :2
5: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :1
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :1
6: splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
-->_1 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :2
7: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :8
8: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :3
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
9: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :3
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, sortAll^#(@l) -> sortAll#1^#(@l) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys))
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, sortAll^#(@l) -> sortAll#1^#(@l) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys))
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We measure the number of applications of following selected rules
relative to the remaining rules.
Selected Rules (A):
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys))
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) }
Remaining Rules (B):
{ sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
The length of a single A-subderivation is expressed by the
following problem.
Problem (A):
------------
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys))
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
The number of B-applications is expressed by the following problem.
Problem (B):
------------
Strict DPs:
{ sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) }
Weak DPs:
{ sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
TcT answers on problem (B) 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:
{ sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) }
Weak DPs:
{ sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the following dependency-graph
1: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :3
2: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :1
3: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :2
4: splitAndSort^#(@l) -> sortAll^#(split(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs) }
Weak DPs:
{ sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs) }
Weak DPs:
{ sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
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: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) }
Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(nil()) -> nil() }
Sub-proof:
----------
The following argument positions are usable:
Uargs(#equal) = {}, Uargs(#eq) = {}, Uargs(#greater) = {},
Uargs(#compare) = {}, Uargs(#ckgt) = {}, Uargs(::) = {},
Uargs(insert) = {}, Uargs(insert#1) = {}, Uargs(tuple#2) = {},
Uargs(insert#2) = {}, Uargs(insert#3) = {}, Uargs(insert#4) = {},
Uargs(splitqs) = {}, Uargs(split) = {}, Uargs(split#1) = {},
Uargs(splitqs#1) = {}, Uargs(splitqs#2) = {},
Uargs(splitqs#3) = {}, Uargs(#and) = {}, Uargs(#neg) = {},
Uargs(#pos) = {}, Uargs(#s) = {}, Uargs(#equal^#) = {},
Uargs(#eq^#) = {}, Uargs(#greater^#) = {}, Uargs(#ckgt^#) = {},
Uargs(#compare^#) = {}, Uargs(append^#) = {},
Uargs(append#1^#) = {}, Uargs(insert^#) = {},
Uargs(insert#1^#) = {}, Uargs(insert#2^#) = {},
Uargs(insert#3^#) = {}, Uargs(insert#4^#) = {},
Uargs(quicksort^#) = {}, Uargs(quicksort#1^#) = {},
Uargs(quicksort#2^#) = {}, Uargs(splitqs^#) = {},
Uargs(splitqs#1^#) = {}, Uargs(sortAll^#) = {},
Uargs(sortAll#1^#) = {}, Uargs(sortAll#2^#) = {},
Uargs(split^#) = {}, Uargs(split#1^#) = {},
Uargs(splitAndSort^#) = {}, Uargs(splitqs#2^#) = {},
Uargs(splitqs#3^#) = {}, Uargs(#and^#) = {}, Uargs(c_3) = {}
TcT has computed following constructor-based matrix interpretation
satisfying not(EDA).
[#equal](x1, x2) = [2] x1 + [2]
[#eq](x1, x2) = [0]
[#greater](x1, x2) = [0]
[#compare](x1, x2) = [0]
[#ckgt](x1) = [0]
[::](x1, x2) = [1] x1 + [1] x2 + [1]
[nil] = [3]
[insert](x1, x2) = [1] x2 + [2]
[insert#1](x1, x2, x3) = [1] x2 + [2]
[tuple#2](x1, x2) = [0]
[insert#2](x1, x2, x3, x4) = [1] x1 + [2]
[insert#3](x1, x2, x3, x4, x5) = [1] x3 + [3]
[insert#4](x1, x2, x3, x4, x5, x6) = [1] x3 + [3]
[#false] = [0]
[#true] = [0]
[splitqs](x1, x2) = [0]
[split](x1) = [3] x1 + [1]
[split#1](x1) = [3] x1 + [0]
[splitqs#1](x1, x2) = [0]
[splitqs#2](x1, x2, x3) = [0]
[splitqs#3](x1, x2, x3, x4) = [0]
[#and](x1, x2) = [0]
[#EQ] = [0]
[#GT] = [0]
[#LT] = [0]
[#0] = [0]
[#neg](x1) = [1] x1 + [0]
[#pos](x1) = [1] x1 + [0]
[#s](x1) = [1] x1 + [0]
[#equal^#](x1, x2) = [0]
[#eq^#](x1, x2) = [0]
[#greater^#](x1, x2) = [0]
[#ckgt^#](x1) = [0]
[#compare^#](x1, x2) = [0]
[append^#](x1, x2) = [0]
[append#1^#](x1, x2) = [0]
[insert^#](x1, x2) = [0]
[insert#1^#](x1, x2, x3) = [0]
[insert#2^#](x1, x2, x3, x4) = [0]
[insert#3^#](x1, x2, x3, x4, x5) = [0]
[insert#4^#](x1, x2, x3, x4, x5, x6) = [0]
[quicksort^#](x1) = [0]
[quicksort#1^#](x1) = [0]
[quicksort#2^#](x1, x2) = [0]
[splitqs^#](x1, x2) = [0]
[splitqs#1^#](x1, x2) = [0]
[sortAll^#](x1) = [1] x1 + [2]
[sortAll#1^#](x1) = [1] x1 + [2]
[sortAll#2^#](x1, x2) = [1] x2 + [2]
[split^#](x1) = [0]
[split#1^#](x1) = [0]
[splitAndSort^#](x1) = [3] x1 + [3]
[splitqs#2^#](x1, x2, x3) = [0]
[splitqs#3^#](x1, x2, x3, x4) = [0]
[#and^#](x1, x2) = [0]
[c_3](x1, x2) = [0]
[c] = [0]
This order satisfies following ordering constraints
[#equal(@x, @y)] = [2] @x + [2]
> [0]
= [#eq(@x, @y)]
[#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [0]
>= [0]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(::(@x_1, @x_2), nil())] = [0]
>= [0]
= [#false()]
[#eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2))] = [0]
>= [0]
= [#false()]
[#eq(nil(), ::(@y_1, @y_2))] = [0]
>= [0]
= [#false()]
[#eq(nil(), nil())] = [0]
>= [0]
= [#true()]
[#eq(nil(), tuple#2(@y_1, @y_2))] = [0]
>= [0]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2))] = [0]
>= [0]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), nil())] = [0]
>= [0]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2))] = [0]
>= [0]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(#0(), #0())] = [0]
>= [0]
= [#true()]
[#eq(#0(), #neg(@y))] = [0]
>= [0]
= [#false()]
[#eq(#0(), #pos(@y))] = [0]
>= [0]
= [#false()]
[#eq(#0(), #s(@y))] = [0]
>= [0]
= [#false()]
[#eq(#neg(@x), #0())] = [0]
>= [0]
= [#false()]
[#eq(#neg(@x), #neg(@y))] = [0]
>= [0]
= [#eq(@x, @y)]
[#eq(#neg(@x), #pos(@y))] = [0]
>= [0]
= [#false()]
[#eq(#pos(@x), #0())] = [0]
>= [0]
= [#false()]
[#eq(#pos(@x), #neg(@y))] = [0]
>= [0]
= [#false()]
[#eq(#pos(@x), #pos(@y))] = [0]
>= [0]
= [#eq(@x, @y)]
[#eq(#s(@x), #0())] = [0]
>= [0]
= [#false()]
[#eq(#s(@x), #s(@y))] = [0]
>= [0]
= [#eq(@x, @y)]
[insert(@x, @l)] = [1] @l + [2]
>= [1] @l + [2]
= [insert#1(@x, @l, @x)]
[insert#1(tuple#2(@valX, @keyX), @l, @x)] = [1] @l + [2]
>= [1] @l + [2]
= [insert#2(@l, @keyX, @valX, @x)]
[insert#2(::(@l1, @ls), @keyX, @valX, @x)] = [1] @l1 + [1] @ls + [3]
>= [1] @ls + [3]
= [insert#3(@l1, @keyX, @ls, @valX, @x)]
[insert#2(nil(), @keyX, @valX, @x)] = [5]
> [4]
= [::(tuple#2(::(@valX, nil()), @keyX), nil())]
[insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x)] = [1] @ls + [3]
>= [1] @ls + [3]
= [insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)]
[insert#4(#false(), @key1, @ls, @valX, @vals1, @x)] = [1] @ls + [3]
>= [1] @ls + [3]
= [::(tuple#2(@vals1, @key1), insert(@x, @ls))]
[insert#4(#true(), @key1, @ls, @valX, @vals1, @x)] = [1] @ls + [3]
> [1] @ls + [1]
= [::(tuple#2(::(@valX, @vals1), @key1), @ls)]
[split(@l)] = [3] @l + [1]
> [3] @l + [0]
= [split#1(@l)]
[split#1(::(@x, @xs))] = [3] @x + [3] @xs + [3]
>= [3] @xs + [3]
= [insert(@x, split(@xs))]
[split#1(nil())] = [9]
> [3]
= [nil()]
[#and(#false(), #false())] = [0]
>= [0]
= [#false()]
[#and(#false(), #true())] = [0]
>= [0]
= [#false()]
[#and(#true(), #false())] = [0]
>= [0]
= [#false()]
[#and(#true(), #true())] = [0]
>= [0]
= [#true()]
[sortAll^#(@l)] = [1] @l + [2]
>= [1] @l + [2]
= [sortAll#1^#(@l)]
[sortAll#1^#(::(@x, @xs))] = [1] @x + [1] @xs + [3]
> [1] @xs + [2]
= [sortAll#2^#(@x, @xs)]
[sortAll#2^#(tuple#2(@vals, @key), @xs)] = [1] @xs + [2]
>= [1] @xs + [2]
= [sortAll^#(@xs)]
[splitAndSort^#(@l)] = [3] @l + [3]
>= [3] @l + [3]
= [sortAll^#(split(@l))]
Processor 'matrix interpretation of dimension 1' induces the
complexity certificate YES(?,O(n^1)) on application of rules {3}.
Here rules are labeled according to the (estimated) dependency
graph
1: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :3
2: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :1
3: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs) :2
4: splitAndSort^#(@l) -> sortAll^#(split(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :1
- The rules {3} have known complexity. These cover all predecessors
of {2,4}, their complexity is equally bounded.
- The rules {2,3,4} have known complexity. These cover all
predecessors of {1}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules
{1,2,3,4} is given by YES(?,O(n^1)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{4} Weak SCC
|
`->2:{1,3,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: sortAll^#(@l) -> sortAll#1^#(@l)
, 2: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, 3: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, 4: splitAndSort^#(@l) -> sortAll^#(split(@l)) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 4: splitAndSort^#(@l) -> sortAll^#(split(@l))
, 1: sortAll^#(@l) -> sortAll#1^#(@l)
, 3: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, 2: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) }
We apply the transformation 'usablerules' on the sub-problem:
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
No rule is usable.
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
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 are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys))
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We measure the number of applications of following selected rules
relative to the remaining rules.
Selected Rules (A):
{ splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) }
Remaining Rules (B):
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
The length of a single A-subderivation is expressed by the
following problem.
Problem (A):
------------
Strict DPs: { splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) }
Weak DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#1^#(::(@z, @zs)) -> splitqs^#(@z, @zs)
, quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs)
, quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys)
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
The number of B-applications is expressed by the following problem.
Problem (B):
------------
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) }
Weak DPs:
{ quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
TcT answers on problem (B) 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:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) }
Weak DPs:
{ quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the (estimated) dependency graph
1: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :2
2: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys)) :3
3: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys))
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :1
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
4: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :5
5: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs) :7
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
quicksort^#(@vals) :6
6: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
7: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :4
8: splitAndSort^#(@l) -> sortAll^#(split(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :4
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { quicksort^#(@l) -> quicksort#1^#(@l) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the following dependency-graph
1: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :2
2: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys)) :3
3: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys))
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :1
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
4: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :5
5: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs) :7
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
quicksort^#(@vals) :6
6: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
7: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :4
8: splitAndSort^#(@l) -> sortAll^#(split(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :4
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { quicksort^#(@l) -> quicksort#1^#(@l) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
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: quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z)
, 6: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, 8: splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Trs:
{ #eq(nil(), nil()) -> #true()
, #eq(#0(), #0()) -> #true()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#s(@x), #0()) -> #GT()
, #ckgt(#EQ()) -> #false()
, #ckgt(#LT()) -> #false()
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, #and(#true(), #true()) -> #true() }
Sub-proof:
----------
The following argument positions are usable:
Uargs(#equal) = {}, Uargs(#eq) = {}, Uargs(#greater) = {},
Uargs(#compare) = {}, Uargs(#ckgt) = {}, Uargs(::) = {},
Uargs(insert) = {}, Uargs(insert#1) = {}, Uargs(tuple#2) = {},
Uargs(insert#2) = {}, Uargs(insert#3) = {}, Uargs(insert#4) = {},
Uargs(splitqs) = {}, Uargs(split) = {}, Uargs(split#1) = {},
Uargs(splitqs#1) = {}, Uargs(splitqs#2) = {},
Uargs(splitqs#3) = {}, Uargs(#and) = {}, Uargs(#neg) = {},
Uargs(#pos) = {}, Uargs(#s) = {}, Uargs(#equal^#) = {},
Uargs(#eq^#) = {}, Uargs(#greater^#) = {}, Uargs(#ckgt^#) = {},
Uargs(#compare^#) = {}, Uargs(append^#) = {},
Uargs(append#1^#) = {}, Uargs(insert^#) = {},
Uargs(insert#1^#) = {}, Uargs(insert#2^#) = {},
Uargs(insert#3^#) = {}, Uargs(insert#4^#) = {},
Uargs(quicksort^#) = {}, Uargs(quicksort#1^#) = {},
Uargs(quicksort#2^#) = {}, Uargs(splitqs^#) = {},
Uargs(splitqs#1^#) = {}, Uargs(sortAll^#) = {},
Uargs(sortAll#1^#) = {}, Uargs(sortAll#2^#) = {},
Uargs(split^#) = {}, Uargs(split#1^#) = {},
Uargs(splitAndSort^#) = {}, Uargs(splitqs#2^#) = {},
Uargs(splitqs#3^#) = {}, Uargs(#and^#) = {}, Uargs(c_1) = {},
Uargs(c_2) = {}, Uargs(c_1) = {1, 2}
TcT has computed following constructor-based matrix interpretation
satisfying not(EDA) and not(IDA(1)).
[#equal](x1, x2) = [1]
[3]
[#eq](x1, x2) = [1]
[1]
[#greater](x1, x2) = [2 0] x1 + [0 1] x2 + [2]
[0 0] [1 0] [1]
[#compare](x1, x2) = [0 0] x1 + [0 0] x2 + [1]
[1 0] [0 1] [0]
[#ckgt](x1) = [2 1] x1 + [0]
[0 0] [1]
[::](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
[0 0] [0 1] [1]
[nil] = [0]
[0]
[insert](x1, x2) = [1 0] x2 + [1]
[0 1] [1]
[insert#1](x1, x2, x3) = [1 0] x2 + [1]
[0 1] [1]
[tuple#2](x1, x2) = [0 1] x1 + [0 0] x2 + [0]
[0 1] [0 1] [0]
[insert#2](x1, x2, x3, x4) = [1 0] x1 + [1]
[0 1] [1]
[insert#3](x1, x2, x3, x4, x5) = [1 0] x1 + [1 0] x3 + [1]
[0 0] [0 1] [2]
[insert#4](x1, x2, x3, x4, x5, x6) = [1 0] x3 + [0 1] x5 + [1]
[0 1] [0 0] [2]
[#false] = [1]
[1]
[#true] = [0]
[0]
[splitqs](x1, x2) = [1 1] x1 + [2 3] x2 + [0]
[0 0] [0 1] [0]
[split](x1) = [0 1] x1 + [0]
[0 1] [0]
[split#1](x1) = [0 1] x1 + [0]
[0 1] [0]
[splitqs#1](x1, x2) = [2 3] x1 + [1 1] x2 + [0]
[0 1] [0 0] [0]
[splitqs#2](x1, x2, x3) = [0 2] x1 + [1 1] x2 + [2
0] x3 + [3]
[0 1] [0 0] [0
0] [1]
[splitqs#3](x1, x2, x3, x4) = [1 1] x1 + [0 2] x2 + [0
0] x3 + [0]
[0 0] [0 1] [0
1] [1]
[#and](x1, x2) = [1]
[1]
[#EQ] = [1]
[2]
[#GT] = [0]
[0]
[#LT] = [1]
[0]
[#0] = [0]
[2]
[#neg](x1) = [0 1] x1 + [0]
[1 0] [0]
[#pos](x1) = [1 0] x1 + [0]
[0 1] [0]
[#s](x1) = [1 0] x1 + [0]
[0 1] [0]
[#equal^#](x1, x2) = [0]
[0]
[#eq^#](x1, x2) = [0]
[0]
[#greater^#](x1, x2) = [0]
[0]
[#ckgt^#](x1) = [0]
[0]
[#compare^#](x1, x2) = [0]
[0]
[append^#](x1, x2) = [0]
[0]
[append#1^#](x1, x2) = [0]
[0]
[insert^#](x1, x2) = [0]
[0]
[insert#1^#](x1, x2, x3) = [0]
[0]
[insert#2^#](x1, x2, x3, x4) = [0]
[0]
[insert#3^#](x1, x2, x3, x4, x5) = [0]
[0]
[insert#4^#](x1, x2, x3, x4, x5, x6) = [0]
[0]
[quicksort^#](x1) = [0 3] x1 + [0]
[0 0] [0]
[quicksort#1^#](x1) = [0 3] x1 + [0]
[0 0] [0]
[quicksort#2^#](x1, x2) = [0 3] x1 + [0]
[0 0] [0]
[splitqs^#](x1, x2) = [0]
[0]
[splitqs#1^#](x1, x2) = [0]
[0]
[sortAll^#](x1) = [3 0] x1 + [2]
[0 0] [0]
[sortAll#1^#](x1) = [3 0] x1 + [2]
[0 0] [0]
[sortAll#2^#](x1, x2) = [3 0] x1 + [3 0] x2 + [2]
[0 0] [0 0] [0]
[split^#](x1) = [0]
[0]
[split#1^#](x1) = [0]
[0]
[splitAndSort^#](x1) = [3 3] x1 + [3]
[3 3] [3]
[splitqs#2^#](x1, x2, x3) = [0]
[0]
[splitqs#3^#](x1, x2, x3, x4) = [0]
[0]
[#and^#](x1, x2) = [0]
[0]
[c_1](x1, x2) = [0]
[0]
[c_2](x1, x2) = [0]
[0]
[c] = [0]
[0]
[c_1](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
[0 0] [0 0] [0]
This order satisfies following ordering constraints
[#equal(@x, @y)] = [1]
[3]
>= [1]
[1]
= [#eq(@x, @y)]
[#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [1]
[1]
>= [1]
[1]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(::(@x_1, @x_2), nil())] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2))] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(nil(), ::(@y_1, @y_2))] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(nil(), nil())] = [1]
[1]
> [0]
[0]
= [#true()]
[#eq(nil(), tuple#2(@y_1, @y_2))] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2))] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), nil())] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2))] = [1]
[1]
>= [1]
[1]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(#0(), #0())] = [1]
[1]
> [0]
[0]
= [#true()]
[#eq(#0(), #neg(@y))] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(#0(), #pos(@y))] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(#0(), #s(@y))] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(#neg(@x), #0())] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(#neg(@x), #neg(@y))] = [1]
[1]
>= [1]
[1]
= [#eq(@x, @y)]
[#eq(#neg(@x), #pos(@y))] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(#pos(@x), #0())] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(#pos(@x), #neg(@y))] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(#pos(@x), #pos(@y))] = [1]
[1]
>= [1]
[1]
= [#eq(@x, @y)]
[#eq(#s(@x), #0())] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(#s(@x), #s(@y))] = [1]
[1]
>= [1]
[1]
= [#eq(@x, @y)]
[#greater(@x, @y)] = [2 0] @x + [0 1] @y + [2]
[0 0] [1 0] [1]
>= [1 0] @x + [0 1] @y + [2]
[0 0] [0 0] [1]
= [#ckgt(#compare(@x, @y))]
[#compare(#0(), #0())] = [1]
[2]
>= [1]
[2]
= [#EQ()]
[#compare(#0(), #neg(@y))] = [0 0] @y + [1]
[1 0] [0]
> [0]
[0]
= [#GT()]
[#compare(#0(), #pos(@y))] = [0 0] @y + [1]
[0 1] [0]
>= [1]
[0]
= [#LT()]
[#compare(#0(), #s(@y))] = [0 0] @y + [1]
[0 1] [0]
>= [1]
[0]
= [#LT()]
[#compare(#neg(@x), #0())] = [0 0] @x + [1]
[0 1] [2]
>= [1]
[0]
= [#LT()]
[#compare(#neg(@x), #neg(@y))] = [0 0] @x + [0 0] @y + [1]
[0 1] [1 0] [0]
>= [0 0] @x + [0 0] @y + [1]
[0 1] [1 0] [0]
= [#compare(@y, @x)]
[#compare(#neg(@x), #pos(@y))] = [0 0] @x + [0 0] @y + [1]
[0 1] [0 1] [0]
>= [1]
[0]
= [#LT()]
[#compare(#pos(@x), #0())] = [0 0] @x + [1]
[1 0] [2]
> [0]
[0]
= [#GT()]
[#compare(#pos(@x), #neg(@y))] = [0 0] @x + [0 0] @y + [1]
[1 0] [1 0] [0]
> [0]
[0]
= [#GT()]
[#compare(#pos(@x), #pos(@y))] = [0 0] @x + [0 0] @y + [1]
[1 0] [0 1] [0]
>= [0 0] @x + [0 0] @y + [1]
[1 0] [0 1] [0]
= [#compare(@x, @y)]
[#compare(#s(@x), #0())] = [0 0] @x + [1]
[1 0] [2]
> [0]
[0]
= [#GT()]
[#compare(#s(@x), #s(@y))] = [0 0] @x + [0 0] @y + [1]
[1 0] [0 1] [0]
>= [0 0] @x + [0 0] @y + [1]
[1 0] [0 1] [0]
= [#compare(@x, @y)]
[#ckgt(#EQ())] = [4]
[1]
> [1]
[1]
= [#false()]
[#ckgt(#GT())] = [0]
[1]
>= [0]
[0]
= [#true()]
[#ckgt(#LT())] = [2]
[1]
> [1]
[1]
= [#false()]
[insert(@x, @l)] = [1 0] @l + [1]
[0 1] [1]
>= [1 0] @l + [1]
[0 1] [1]
= [insert#1(@x, @l, @x)]
[insert#1(tuple#2(@valX, @keyX), @l, @x)] = [1 0] @l + [1]
[0 1] [1]
>= [1 0] @l + [1]
[0 1] [1]
= [insert#2(@l, @keyX, @valX, @x)]
[insert#2(::(@l1, @ls), @keyX, @valX, @x)] = [1 0] @l1 + [1 0] @ls + [1]
[0 0] [0 1] [2]
>= [1 0] @l1 + [1 0] @ls + [1]
[0 0] [0 1] [2]
= [insert#3(@l1, @keyX, @ls, @valX, @x)]
[insert#2(nil(), @keyX, @valX, @x)] = [1]
[1]
>= [1]
[1]
= [::(tuple#2(::(@valX, nil()), @keyX), nil())]
[insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x)] = [1 0] @ls + [0 1] @vals1 + [1]
[0 1] [0 0] [2]
>= [1 0] @ls + [0 1] @vals1 + [1]
[0 1] [0 0] [2]
= [insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)]
[insert#4(#false(), @key1, @ls, @valX, @vals1, @x)] = [1 0] @ls + [0 1] @vals1 + [1]
[0 1] [0 0] [2]
>= [1 0] @ls + [0 1] @vals1 + [1]
[0 1] [0 0] [2]
= [::(tuple#2(@vals1, @key1), insert(@x, @ls))]
[insert#4(#true(), @key1, @ls, @valX, @vals1, @x)] = [1 0] @ls + [0 1] @vals1 + [1]
[0 1] [0 0] [2]
>= [1 0] @ls + [0 1] @vals1 + [1]
[0 1] [0 0] [1]
= [::(tuple#2(::(@valX, @vals1), @key1), @ls)]
[splitqs(@pivot, @l)] = [2 3] @l + [1 1] @pivot + [0]
[0 1] [0 0] [0]
>= [2 3] @l + [1 1] @pivot + [0]
[0 1] [0 0] [0]
= [splitqs#1(@l, @pivot)]
[split(@l)] = [0 1] @l + [0]
[0 1] [0]
>= [0 1] @l + [0]
[0 1] [0]
= [split#1(@l)]
[split#1(::(@x, @xs))] = [0 1] @xs + [1]
[0 1] [1]
>= [0 1] @xs + [1]
[0 1] [1]
= [insert(@x, split(@xs))]
[split#1(nil())] = [0]
[0]
>= [0]
[0]
= [nil()]
[splitqs#1(::(@x, @xs), @pivot)] = [1 1] @pivot + [2 0] @x + [2 3] @xs + [3]
[0 0] [0 0] [0 1] [1]
>= [1 1] @pivot + [2 0] @x + [0 2] @xs + [3]
[0 0] [0 0] [0 1] [1]
= [splitqs#2(splitqs(@pivot, @xs), @pivot, @x)]
[splitqs#1(nil(), @pivot)] = [1 1] @pivot + [0]
[0 0] [0]
>= [0]
[0]
= [tuple#2(nil(), nil())]
[splitqs#2(tuple#2(@ls, @rs), @pivot, @x)] = [0 2] @ls + [1 1] @pivot + [0 2] @rs + [2 0] @x + [3]
[0 1] [0 0] [0 1] [0 0] [1]
>= [0 2] @ls + [1 1] @pivot + [0 0] @rs + [2 0] @x + [3]
[0 1] [0 0] [0 1] [0 0] [1]
= [splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)]
[splitqs#3(#false(), @ls, @rs, @x)] = [0 2] @ls + [0 0] @rs + [2]
[0 1] [0 1] [1]
> [0 1] @ls + [0 0] @rs + [1]
[0 1] [0 1] [1]
= [tuple#2(::(@x, @ls), @rs)]
[splitqs#3(#true(), @ls, @rs, @x)] = [0 2] @ls + [0 0] @rs + [0]
[0 1] [0 1] [1]
>= [0 1] @ls + [0 0] @rs + [0]
[0 1] [0 1] [1]
= [tuple#2(@ls, ::(@x, @rs))]
[#and(#false(), #false())] = [1]
[1]
>= [1]
[1]
= [#false()]
[#and(#false(), #true())] = [1]
[1]
>= [1]
[1]
= [#false()]
[#and(#true(), #false())] = [1]
[1]
>= [1]
[1]
= [#false()]
[#and(#true(), #true())] = [1]
[1]
> [0]
[0]
= [#true()]
[quicksort^#(@l)] = [0 3] @l + [0]
[0 0] [0]
>= [0 3] @l + [0]
[0 0] [0]
= [quicksort#1^#(@l)]
[quicksort#1^#(::(@z, @zs))] = [0 3] @zs + [3]
[0 0] [0]
> [0 3] @zs + [0]
[0 0] [0]
= [quicksort#2^#(splitqs(@z, @zs), @z)]
[quicksort#2^#(tuple#2(@xs, @ys), @z)] = [0 3] @xs + [0 3] @ys + [0]
[0 0] [0 0] [0]
>= [0 3] @xs + [0 3] @ys + [0]
[0 0] [0 0] [0]
= [c_1(quicksort^#(@xs), quicksort^#(@ys))]
[sortAll^#(@l)] = [3 0] @l + [2]
[0 0] [0]
>= [3 0] @l + [2]
[0 0] [0]
= [sortAll#1^#(@l)]
[sortAll#1^#(::(@x, @xs))] = [3 0] @x + [3 0] @xs + [2]
[0 0] [0 0] [0]
>= [3 0] @x + [3 0] @xs + [2]
[0 0] [0 0] [0]
= [sortAll#2^#(@x, @xs)]
[sortAll#2^#(tuple#2(@vals, @key), @xs)] = [0 3] @vals + [3 0] @xs + [2]
[0 0] [0 0] [0]
> [0 3] @vals + [0]
[0 0] [0]
= [quicksort^#(@vals)]
[sortAll#2^#(tuple#2(@vals, @key), @xs)] = [0 3] @vals + [3 0] @xs + [2]
[0 0] [0 0] [0]
>= [3 0] @xs + [2]
[0 0] [0]
= [sortAll^#(@xs)]
[splitAndSort^#(@l)] = [3 3] @l + [3]
[3 3] [3]
> [0 3] @l + [2]
[0 0] [0]
= [sortAll^#(split(@l))]
Processor 'matrix interpretation of dimension 2' induces the
complexity certificate YES(?,O(n^1)) on application of rules
{2,6,8}. Here rules are labeled according to the (estimated)
dependency graph
1: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z) :2
2: quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z)
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys)) :3
3: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys))
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :1
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
4: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :5
5: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs) :7
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
quicksort^#(@vals) :6
6: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
7: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :4
8: splitAndSort^#(@l) -> sortAll^#(split(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :4
- The rules {2,6,8} have known complexity. These cover all
predecessors of {3}, their complexity is equally bounded.
- The rules {2,3,6,8} have known complexity. These cover all
predecessors of {1}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules
{1,2,3,6,8} is given by YES(?,O(n^1)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{8} Weak SCC
|
`->2:{4,7,5} Weak SCC
|
`->3:{6} Weak SCC
|
`->4:{1,3,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: quicksort^#(@l) -> quicksort#1^#(@l)
, 2: quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z)
, 3: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys))
, 4: sortAll^#(@l) -> sortAll#1^#(@l)
, 5: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, 6: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, 7: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, 8: splitAndSort^#(@l) -> sortAll^#(split(@l)) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 8: splitAndSort^#(@l) -> sortAll^#(split(@l))
, 4: sortAll^#(@l) -> sortAll#1^#(@l)
, 7: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, 5: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, 6: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, 1: quicksort^#(@l) -> quicksort#1^#(@l)
, 3: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys))
, 2: quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z) }
We apply the transformation 'usablerules' on the sub-problem:
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
No rule is usable.
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
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 are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) }
Weak DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#1^#(::(@z, @zs)) -> splitqs^#(@z, @zs)
, quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs)
, quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys)
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
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:
{ 4: quicksort#1^#(::(@z, @zs)) -> splitqs^#(@z, @zs)
, 7: splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, 11: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, 12: splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Trs:
{ #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#LT()) -> #false()
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split#1(nil()) -> nil()
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs)) }
Sub-proof:
----------
The following argument positions are usable:
Uargs(#equal) = {}, Uargs(#eq) = {}, Uargs(#greater) = {},
Uargs(#compare) = {}, Uargs(#ckgt) = {}, Uargs(::) = {},
Uargs(insert) = {}, Uargs(insert#1) = {}, Uargs(tuple#2) = {},
Uargs(insert#2) = {}, Uargs(insert#3) = {}, Uargs(insert#4) = {},
Uargs(splitqs) = {}, Uargs(split) = {}, Uargs(split#1) = {},
Uargs(splitqs#1) = {}, Uargs(splitqs#2) = {},
Uargs(splitqs#3) = {}, Uargs(#and) = {}, Uargs(#neg) = {},
Uargs(#pos) = {}, Uargs(#s) = {}, Uargs(#equal^#) = {},
Uargs(#eq^#) = {}, Uargs(#greater^#) = {}, Uargs(#ckgt^#) = {},
Uargs(#compare^#) = {}, Uargs(append^#) = {},
Uargs(append#1^#) = {}, Uargs(insert^#) = {},
Uargs(insert#1^#) = {}, Uargs(insert#2^#) = {},
Uargs(insert#3^#) = {}, Uargs(insert#4^#) = {},
Uargs(quicksort^#) = {}, Uargs(quicksort#1^#) = {},
Uargs(quicksort#2^#) = {}, Uargs(splitqs^#) = {},
Uargs(splitqs#1^#) = {}, Uargs(sortAll^#) = {},
Uargs(sortAll#1^#) = {}, Uargs(sortAll#2^#) = {},
Uargs(split^#) = {}, Uargs(split#1^#) = {},
Uargs(splitAndSort^#) = {}, Uargs(splitqs#2^#) = {},
Uargs(splitqs#3^#) = {}, Uargs(#and^#) = {}
TcT has computed following constructor-based matrix interpretation
satisfying not(EDA) and not(IDA(1)).
[#equal](x1, x2) = [0 0] x1 + [0 0] x2 + [1]
[2 2] [2 0] [2]
[#eq](x1, x2) = [0 0] x1 + [0 0] x2 + [1]
[2 2] [2 0] [2]
[#greater](x1, x2) = [1 2] x1 + [1 2] x2 + [2]
[2 3] [2 3] [3]
[#compare](x1, x2) = [1 1] x1 + [1 1] x2 + [0]
[0 0] [0 0] [1]
[#ckgt](x1) = [1 1] x1 + [0]
[2 1] [1]
[::](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
[0 0] [0 1] [1]
[nil] = [1]
[1]
[insert](x1, x2) = [1 0] x2 + [3]
[0 1] [1]
[insert#1](x1, x2, x3) = [1 0] x2 + [3]
[0 1] [1]
[tuple#2](x1, x2) = [0 1] x1 + [0 0] x2 + [1]
[0 1] [0 1] [1]
[insert#2](x1, x2, x3, x4) = [1 0] x1 + [3]
[0 1] [1]
[insert#3](x1, x2, x3, x4, x5) = [1 0] x1 + [1 0] x3 + [3]
[0 0] [0 1] [2]
[insert#4](x1, x2, x3, x4, x5, x6) = [1 0] x1 + [1 0] x3 + [0
1] x5 + [3]
[0 0] [0 1] [0
0] [2]
[#false] = [1]
[3]
[#true] = [1]
[0]
[splitqs](x1, x2) = [1 1] x2 + [1]
[0 1] [2]
[split](x1) = [2 3] x1 + [2]
[0 2] [1]
[split#1](x1) = [2 3] x1 + [2]
[0 2] [1]
[splitqs#1](x1, x2) = [1 1] x1 + [1]
[0 1] [2]
[splitqs#2](x1, x2, x3) = [1 0] x1 + [1 0] x3 + [1]
[0 1] [0 0] [1]
[splitqs#3](x1, x2, x3, x4) = [0 1] x2 + [0 0] x3 + [1
0] x4 + [2]
[0 1] [0 1] [0
0] [2]
[#and](x1, x2) = [0 0] x1 + [0 0] x2 + [1]
[1 0] [1 0] [1]
[#EQ] = [2]
[1]
[#GT] = [1]
[0]
[#LT] = [2]
[0]
[#0] = [2]
[2]
[#neg](x1) = [1 0] x1 + [0]
[0 1] [2]
[#pos](x1) = [1 0] x1 + [0]
[0 1] [1]
[#s](x1) = [1 0] x1 + [0]
[0 1] [2]
[#equal^#](x1, x2) = [0]
[0]
[#eq^#](x1, x2) = [0]
[0]
[#greater^#](x1, x2) = [0]
[0]
[#ckgt^#](x1) = [0]
[0]
[#compare^#](x1, x2) = [0]
[0]
[append^#](x1, x2) = [0]
[0]
[append#1^#](x1, x2) = [0]
[0]
[insert^#](x1, x2) = [0]
[0]
[insert#1^#](x1, x2, x3) = [0]
[0]
[insert#2^#](x1, x2, x3, x4) = [0]
[0]
[insert#3^#](x1, x2, x3, x4, x5) = [0]
[0]
[insert#4^#](x1, x2, x3, x4, x5, x6) = [0]
[0]
[quicksort^#](x1) = [0 1] x1 + [1]
[0 0] [0]
[quicksort#1^#](x1) = [0 1] x1 + [1]
[0 0] [0]
[quicksort#2^#](x1, x2) = [0 1] x1 + [0]
[0 0] [0]
[splitqs^#](x1, x2) = [0 1] x2 + [0]
[0 0] [0]
[splitqs#1^#](x1, x2) = [0 1] x1 + [0]
[0 0] [0]
[sortAll^#](x1) = [1 0] x1 + [0]
[0 0] [0]
[sortAll#1^#](x1) = [1 0] x1 + [0]
[0 0] [0]
[sortAll#2^#](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
[0 0] [0 0] [0]
[split^#](x1) = [0]
[0]
[split#1^#](x1) = [0]
[0]
[splitAndSort^#](x1) = [3 3] x1 + [3]
[3 3] [3]
[splitqs#2^#](x1, x2, x3) = [0]
[0]
[splitqs#3^#](x1, x2, x3, x4) = [0]
[0]
[#and^#](x1, x2) = [0]
[0]
This order satisfies following ordering constraints
[#equal(@x, @y)] = [0 0] @x + [0 0] @y + [1]
[2 2] [2 0] [2]
>= [0 0] @x + [0 0] @y + [1]
[2 2] [2 0] [2]
= [#eq(@x, @y)]
[#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [0 0] @x_1 + [0 0] @x_2 + [0 0] @y_1 + [0 0] @y_2 + [1]
[2 0] [2 2] [2 0] [2 0] [4]
>= [1]
[3]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(::(@x_1, @x_2), nil())] = [0 0] @x_1 + [0 0] @x_2 + [1]
[2 0] [2 2] [6]
>= [1]
[3]
= [#false()]
[#eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2))] = [0 0] @x_1 + [0 0] @x_2 + [0 0] @y_1 + [1]
[2 0] [2 2] [0 2] [6]
>= [1]
[3]
= [#false()]
[#eq(nil(), ::(@y_1, @y_2))] = [0 0] @y_1 + [0 0] @y_2 + [1]
[2 0] [2 0] [6]
>= [1]
[3]
= [#false()]
[#eq(nil(), nil())] = [1]
[8]
>= [1]
[0]
= [#true()]
[#eq(nil(), tuple#2(@y_1, @y_2))] = [0 0] @y_1 + [1]
[0 2] [8]
>= [1]
[3]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2))] = [0 0] @x_1 + [0 0] @x_2 + [0 0] @y_1 + [0 0] @y_2 + [1]
[0 4] [0 2] [2 0] [2 0] [6]
>= [1]
[3]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), nil())] = [0 0] @x_1 + [0 0] @x_2 + [1]
[0 4] [0 2] [8]
>= [1]
[3]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2))] = [0 0] @x_1 + [0 0] @x_2 + [0 0] @y_1 + [1]
[0 4] [0 2] [0 2] [8]
>= [1]
[3]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(#0(), #0())] = [1]
[14]
>= [1]
[0]
= [#true()]
[#eq(#0(), #neg(@y))] = [0 0] @y + [1]
[2 0] [10]
>= [1]
[3]
= [#false()]
[#eq(#0(), #pos(@y))] = [0 0] @y + [1]
[2 0] [10]
>= [1]
[3]
= [#false()]
[#eq(#0(), #s(@y))] = [0 0] @y + [1]
[2 0] [10]
>= [1]
[3]
= [#false()]
[#eq(#neg(@x), #0())] = [0 0] @x + [1]
[2 2] [10]
>= [1]
[3]
= [#false()]
[#eq(#neg(@x), #neg(@y))] = [0 0] @x + [0 0] @y + [1]
[2 2] [2 0] [6]
>= [0 0] @x + [0 0] @y + [1]
[2 2] [2 0] [2]
= [#eq(@x, @y)]
[#eq(#neg(@x), #pos(@y))] = [0 0] @x + [0 0] @y + [1]
[2 2] [2 0] [6]
>= [1]
[3]
= [#false()]
[#eq(#pos(@x), #0())] = [0 0] @x + [1]
[2 2] [8]
>= [1]
[3]
= [#false()]
[#eq(#pos(@x), #neg(@y))] = [0 0] @x + [0 0] @y + [1]
[2 2] [2 0] [4]
>= [1]
[3]
= [#false()]
[#eq(#pos(@x), #pos(@y))] = [0 0] @x + [0 0] @y + [1]
[2 2] [2 0] [4]
>= [0 0] @x + [0 0] @y + [1]
[2 2] [2 0] [2]
= [#eq(@x, @y)]
[#eq(#s(@x), #0())] = [0 0] @x + [1]
[2 2] [10]
>= [1]
[3]
= [#false()]
[#eq(#s(@x), #s(@y))] = [0 0] @x + [0 0] @y + [1]
[2 2] [2 0] [6]
>= [0 0] @x + [0 0] @y + [1]
[2 2] [2 0] [2]
= [#eq(@x, @y)]
[#greater(@x, @y)] = [1 2] @x + [1 2] @y + [2]
[2 3] [2 3] [3]
> [1 1] @x + [1 1] @y + [1]
[2 2] [2 2] [2]
= [#ckgt(#compare(@x, @y))]
[#compare(#0(), #0())] = [8]
[1]
> [2]
[1]
= [#EQ()]
[#compare(#0(), #neg(@y))] = [1 1] @y + [6]
[0 0] [1]
> [1]
[0]
= [#GT()]
[#compare(#0(), #pos(@y))] = [1 1] @y + [5]
[0 0] [1]
> [2]
[0]
= [#LT()]
[#compare(#0(), #s(@y))] = [1 1] @y + [6]
[0 0] [1]
> [2]
[0]
= [#LT()]
[#compare(#neg(@x), #0())] = [1 1] @x + [6]
[0 0] [1]
> [2]
[0]
= [#LT()]
[#compare(#neg(@x), #neg(@y))] = [1 1] @x + [1 1] @y + [4]
[0 0] [0 0] [1]
> [1 1] @x + [1 1] @y + [0]
[0 0] [0 0] [1]
= [#compare(@y, @x)]
[#compare(#neg(@x), #pos(@y))] = [1 1] @x + [1 1] @y + [3]
[0 0] [0 0] [1]
> [2]
[0]
= [#LT()]
[#compare(#pos(@x), #0())] = [1 1] @x + [5]
[0 0] [1]
> [1]
[0]
= [#GT()]
[#compare(#pos(@x), #neg(@y))] = [1 1] @x + [1 1] @y + [3]
[0 0] [0 0] [1]
> [1]
[0]
= [#GT()]
[#compare(#pos(@x), #pos(@y))] = [1 1] @x + [1 1] @y + [2]
[0 0] [0 0] [1]
> [1 1] @x + [1 1] @y + [0]
[0 0] [0 0] [1]
= [#compare(@x, @y)]
[#compare(#s(@x), #0())] = [1 1] @x + [6]
[0 0] [1]
> [1]
[0]
= [#GT()]
[#compare(#s(@x), #s(@y))] = [1 1] @x + [1 1] @y + [4]
[0 0] [0 0] [1]
> [1 1] @x + [1 1] @y + [0]
[0 0] [0 0] [1]
= [#compare(@x, @y)]
[#ckgt(#EQ())] = [3]
[6]
> [1]
[3]
= [#false()]
[#ckgt(#GT())] = [1]
[3]
>= [1]
[0]
= [#true()]
[#ckgt(#LT())] = [2]
[5]
> [1]
[3]
= [#false()]
[insert(@x, @l)] = [1 0] @l + [3]
[0 1] [1]
>= [1 0] @l + [3]
[0 1] [1]
= [insert#1(@x, @l, @x)]
[insert#1(tuple#2(@valX, @keyX), @l, @x)] = [1 0] @l + [3]
[0 1] [1]
>= [1 0] @l + [3]
[0 1] [1]
= [insert#2(@l, @keyX, @valX, @x)]
[insert#2(::(@l1, @ls), @keyX, @valX, @x)] = [1 0] @l1 + [1 0] @ls + [3]
[0 0] [0 1] [2]
>= [1 0] @l1 + [1 0] @ls + [3]
[0 0] [0 1] [2]
= [insert#3(@l1, @keyX, @ls, @valX, @x)]
[insert#2(nil(), @keyX, @valX, @x)] = [4]
[2]
>= [4]
[2]
= [::(tuple#2(::(@valX, nil()), @keyX), nil())]
[insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x)] = [1 0] @ls + [0 1] @vals1 + [4]
[0 1] [0 0] [2]
>= [1 0] @ls + [0 1] @vals1 + [4]
[0 1] [0 0] [2]
= [insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)]
[insert#4(#false(), @key1, @ls, @valX, @vals1, @x)] = [1 0] @ls + [0 1] @vals1 + [4]
[0 1] [0 0] [2]
>= [1 0] @ls + [0 1] @vals1 + [4]
[0 1] [0 0] [2]
= [::(tuple#2(@vals1, @key1), insert(@x, @ls))]
[insert#4(#true(), @key1, @ls, @valX, @vals1, @x)] = [1 0] @ls + [0 1] @vals1 + [4]
[0 1] [0 0] [2]
> [1 0] @ls + [0 1] @vals1 + [2]
[0 1] [0 0] [1]
= [::(tuple#2(::(@valX, @vals1), @key1), @ls)]
[splitqs(@pivot, @l)] = [1 1] @l + [1]
[0 1] [2]
>= [1 1] @l + [1]
[0 1] [2]
= [splitqs#1(@l, @pivot)]
[split(@l)] = [2 3] @l + [2]
[0 2] [1]
>= [2 3] @l + [2]
[0 2] [1]
= [split#1(@l)]
[split#1(::(@x, @xs))] = [2 0] @x + [2 3] @xs + [5]
[0 0] [0 2] [3]
>= [2 3] @xs + [5]
[0 2] [2]
= [insert(@x, split(@xs))]
[split#1(nil())] = [7]
[3]
> [1]
[1]
= [nil()]
[splitqs#1(::(@x, @xs), @pivot)] = [1 0] @x + [1 1] @xs + [2]
[0 0] [0 1] [3]
>= [1 0] @x + [1 1] @xs + [2]
[0 0] [0 1] [3]
= [splitqs#2(splitqs(@pivot, @xs), @pivot, @x)]
[splitqs#1(nil(), @pivot)] = [3]
[3]
> [2]
[3]
= [tuple#2(nil(), nil())]
[splitqs#2(tuple#2(@ls, @rs), @pivot, @x)] = [0 1] @ls + [0 0] @rs + [1 0] @x + [2]
[0 1] [0 1] [0 0] [2]
>= [0 1] @ls + [0 0] @rs + [1 0] @x + [2]
[0 1] [0 1] [0 0] [2]
= [splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)]
[splitqs#3(#false(), @ls, @rs, @x)] = [0 1] @ls + [0 0] @rs + [1 0] @x + [2]
[0 1] [0 1] [0 0] [2]
>= [0 1] @ls + [0 0] @rs + [2]
[0 1] [0 1] [2]
= [tuple#2(::(@x, @ls), @rs)]
[splitqs#3(#true(), @ls, @rs, @x)] = [0 1] @ls + [0 0] @rs + [1 0] @x + [2]
[0 1] [0 1] [0 0] [2]
> [0 1] @ls + [0 0] @rs + [1]
[0 1] [0 1] [2]
= [tuple#2(@ls, ::(@x, @rs))]
[#and(#false(), #false())] = [1]
[3]
>= [1]
[3]
= [#false()]
[#and(#false(), #true())] = [1]
[3]
>= [1]
[3]
= [#false()]
[#and(#true(), #false())] = [1]
[3]
>= [1]
[3]
= [#false()]
[#and(#true(), #true())] = [1]
[3]
>= [1]
[0]
= [#true()]
[quicksort^#(@l)] = [0 1] @l + [1]
[0 0] [0]
>= [0 1] @l + [1]
[0 0] [0]
= [quicksort#1^#(@l)]
[quicksort#1^#(::(@z, @zs))] = [0 1] @zs + [2]
[0 0] [0]
>= [0 1] @zs + [2]
[0 0] [0]
= [quicksort#2^#(splitqs(@z, @zs), @z)]
[quicksort#1^#(::(@z, @zs))] = [0 1] @zs + [2]
[0 0] [0]
> [0 1] @zs + [0]
[0 0] [0]
= [splitqs^#(@z, @zs)]
[quicksort#2^#(tuple#2(@xs, @ys), @z)] = [0 1] @xs + [0 1] @ys + [1]
[0 0] [0 0] [0]
>= [0 1] @xs + [1]
[0 0] [0]
= [quicksort^#(@xs)]
[quicksort#2^#(tuple#2(@xs, @ys), @z)] = [0 1] @xs + [0 1] @ys + [1]
[0 0] [0 0] [0]
>= [0 1] @ys + [1]
[0 0] [0]
= [quicksort^#(@ys)]
[splitqs^#(@pivot, @l)] = [0 1] @l + [0]
[0 0] [0]
>= [0 1] @l + [0]
[0 0] [0]
= [splitqs#1^#(@l, @pivot)]
[splitqs#1^#(::(@x, @xs), @pivot)] = [0 1] @xs + [1]
[0 0] [0]
> [0 1] @xs + [0]
[0 0] [0]
= [splitqs^#(@pivot, @xs)]
[sortAll^#(@l)] = [1 0] @l + [0]
[0 0] [0]
>= [1 0] @l + [0]
[0 0] [0]
= [sortAll#1^#(@l)]
[sortAll#1^#(::(@x, @xs))] = [1 0] @x + [1 0] @xs + [0]
[0 0] [0 0] [0]
>= [1 0] @x + [1 0] @xs + [0]
[0 0] [0 0] [0]
= [sortAll#2^#(@x, @xs)]
[sortAll#2^#(tuple#2(@vals, @key), @xs)] = [0 1] @vals + [1 0] @xs + [1]
[0 0] [0 0] [0]
>= [0 1] @vals + [1]
[0 0] [0]
= [quicksort^#(@vals)]
[sortAll#2^#(tuple#2(@vals, @key), @xs)] = [0 1] @vals + [1 0] @xs + [1]
[0 0] [0 0] [0]
> [1 0] @xs + [0]
[0 0] [0]
= [sortAll^#(@xs)]
[splitAndSort^#(@l)] = [3 3] @l + [3]
[3 3] [3]
> [2 3] @l + [2]
[0 0] [0]
= [sortAll^#(split(@l))]
Processor 'matrix interpretation of dimension 2' induces the
complexity certificate YES(?,O(n^1)) on application of rules
{4,7,11,12}. Here rules are labeled according to the (estimated)
dependency graph
1: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
-->_1 splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) :7
2: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) -> splitqs^#(@z, @zs) :4
-->_1 quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z) :3
3: quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z)
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys) :6
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs) :5
4: quicksort#1^#(::(@z, @zs)) -> splitqs^#(@z, @zs)
-->_1 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :1
5: quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs)
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :2
6: quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys)
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :2
7: splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
-->_1 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :1
8: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :9
9: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs) :11
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
quicksort^#(@vals) :10
10: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :2
11: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :8
12: splitAndSort^#(@l) -> sortAll^#(split(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :8
- The rules {4,7,11,12} have known complexity. These cover all
predecessors of {1,8}, their complexity is equally bounded.
- The rules {1,4,7,8,11,12} have known complexity. These cover all
predecessors of {9}, their complexity is equally bounded.
- The rules {1,4,7,8,9,11,12} have known complexity. These cover
all predecessors of {10}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules
{1,4,7,8,9,10,11,12} is given by YES(?,O(n^1)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#1^#(::(@z, @zs)) -> splitqs^#(@z, @zs)
, quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs)
, quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys)
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{12} Weak SCC
|
`->2:{8,11,9} Weak SCC
|
`->3:{10} Weak SCC
|
`->4:{1,5,2,4} Weak SCC
|
`->5:{3} Weak SCC
|
`->6:{6,7} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: quicksort^#(@l) -> quicksort#1^#(@l)
, 2: quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z)
, 3: quicksort#1^#(::(@z, @zs)) -> splitqs^#(@z, @zs)
, 4: quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs)
, 5: quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys)
, 6: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, 7: splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, 8: sortAll^#(@l) -> sortAll#1^#(@l)
, 9: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, 10: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, 11: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, 12: splitAndSort^#(@l) -> sortAll^#(split(@l)) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 12: splitAndSort^#(@l) -> sortAll^#(split(@l))
, 8: sortAll^#(@l) -> sortAll#1^#(@l)
, 11: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, 9: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, 10: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, 1: quicksort^#(@l) -> quicksort#1^#(@l)
, 5: quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys)
, 2: quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z)
, 4: quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs)
, 3: quicksort#1^#(::(@z, @zs)) -> splitqs^#(@z, @zs)
, 6: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, 7: splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) }
We apply the transformation 'usablerules' on the sub-problem:
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
No rule is usable.
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
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
* Path 1:{18}->2:{16,17}->6:{3,7,6,5,4}: YES(O(1),O(n^2))
-------------------------------------------------------
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the (estimated) dependency graph
1: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
-->_1 insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x) :2
2: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
-->_1 insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x) :3
3: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
-->_1 insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x) :4
4: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
-->_1 insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) :5
5: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
6: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs)) :7
7: split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
-->_2 split^#(@l) -> split#1^#(@l) :6
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
8: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_2 split^#(@l) -> split#1^#(@l) :6
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {5} and add Pre({5}) = {4} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the (estimated) dependency graph
1: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
-->_1 insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x) :2
2: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
-->_1 insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x) :3
3: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
-->_1 insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x) :4
4: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
-->_1 insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) :8
5: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs)) :6
6: split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
-->_2 split^#(@l) -> split#1^#(@l) :5
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
7: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_2 split^#(@l) -> split#1^#(@l) :5
8: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {4} and add Pre({4}) = {3} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the (estimated) dependency graph
1: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
-->_1 insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x) :2
2: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
-->_1 insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x) :3
3: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
-->_1 insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x) :7
4: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs)) :5
5: split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
-->_2 split^#(@l) -> split#1^#(@l) :4
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
6: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_2 split^#(@l) -> split#1^#(@l) :4
7: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
-->_1 insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) :8
8: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the (estimated) dependency graph
1: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
-->_1 insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x) :2
2: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
-->_1 insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x) :6
3: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs)) :4
4: split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
-->_2 split^#(@l) -> split#1^#(@l) :3
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
5: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_2 split^#(@l) -> split#1^#(@l) :3
6: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
-->_1 insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x) :7
7: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
-->_1 insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) :8
8: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the (estimated) dependency graph
1: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
-->_1 insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x) :5
2: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs)) :3
3: split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
-->_2 split^#(@l) -> split#1^#(@l) :2
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
4: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_2 split^#(@l) -> split#1^#(@l) :2
5: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
-->_1 insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x) :6
6: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
-->_1 insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x) :7
7: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
-->_1 insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) :8
8: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, split^#(@l) -> split#1^#(@l)
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the (estimated) dependency graph
1: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
-->_1 insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x) :4
2: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs)) :8
3: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_2 split^#(@l) -> split#1^#(@l) :2
4: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
-->_1 insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x) :5
5: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
-->_1 insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x) :6
6: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
-->_1 insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) :7
7: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
8: split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
-->_2 split^#(@l) -> split#1^#(@l) :2
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, split^#(@l) -> split#1^#(@l) }
Weak DPs:
{ insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the following dependency-graph
1: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
-->_1 insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x) :3
2: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs)) :7
3: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
-->_1 insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x) :4
4: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
-->_1 insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x) :5
5: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
-->_1 insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) :6
6: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
7: split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
-->_2 split^#(@l) -> split#1^#(@l) :2
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
8: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_2 split^#(@l) -> split#1^#(@l) :2
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, split^#(@l) -> split#1^#(@l) }
Weak DPs:
{ insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, split#1^#(::(@x, @xs)) ->
c_1(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> split^#(@l) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, split^#(@l) -> split#1^#(@l) }
Weak DPs:
{ insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, split#1^#(::(@x, @xs)) ->
c_1(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> split^#(@l) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We use the processor 'matrix interpretation of dimension 2' to
orient following rules strictly.
DPs:
{ 2: split^#(@l) -> split#1^#(@l)
, 4: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, 7: split#1^#(::(@x, @xs)) ->
c_1(insert^#(@x, split(@xs)), split^#(@xs)) }
Trs:
{ insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split#1(nil()) -> nil() }
Sub-proof:
----------
The following argument positions are usable:
Uargs(#equal) = {}, Uargs(#eq) = {}, Uargs(::) = {},
Uargs(insert) = {}, Uargs(insert#1) = {}, Uargs(tuple#2) = {},
Uargs(insert#2) = {}, Uargs(insert#3) = {}, Uargs(insert#4) = {},
Uargs(split) = {}, Uargs(split#1) = {}, Uargs(#and) = {},
Uargs(#neg) = {}, Uargs(#pos) = {}, Uargs(#s) = {},
Uargs(#equal^#) = {}, Uargs(#eq^#) = {}, Uargs(#greater^#) = {},
Uargs(#ckgt^#) = {}, Uargs(#compare^#) = {}, Uargs(append^#) = {},
Uargs(append#1^#) = {}, Uargs(insert^#) = {},
Uargs(insert#1^#) = {}, Uargs(insert#2^#) = {},
Uargs(insert#3^#) = {}, Uargs(insert#4^#) = {},
Uargs(quicksort^#) = {}, Uargs(quicksort#1^#) = {},
Uargs(quicksort#2^#) = {}, Uargs(splitqs^#) = {},
Uargs(splitqs#1^#) = {}, Uargs(sortAll^#) = {},
Uargs(sortAll#1^#) = {}, Uargs(sortAll#2^#) = {},
Uargs(split^#) = {}, Uargs(split#1^#) = {},
Uargs(splitAndSort^#) = {}, Uargs(splitqs#2^#) = {},
Uargs(splitqs#3^#) = {}, Uargs(#and^#) = {}, Uargs(c_1) = {1, 2}
TcT has computed following constructor-based matrix interpretation
satisfying not(EDA).
[#equal](x1, x2) = [0]
[2]
[#eq](x1, x2) = [0]
[2]
[::](x1, x2) = [0 0] x1 + [1 0] x2 + [1]
[1 1] [1 1] [1]
[nil] = [0]
[0]
[insert](x1, x2) = [1 0] x2 + [1]
[2 1] [1]
[insert#1](x1, x2, x3) = [1 0] x2 + [1]
[2 1] [1]
[tuple#2](x1, x2) = [0]
[0]
[insert#2](x1, x2, x3, x4) = [1 0] x1 + [1]
[2 1] [1]
[insert#3](x1, x2, x3, x4, x5) = [0 0] x1 + [1 0] x3 + [2]
[1 1] [3 1] [3]
[insert#4](x1, x2, x3, x4, x5, x6) = [0 0] x1 + [1 0] x3 + [2]
[3 0] [3 1] [3]
[#false] = [0]
[1]
[#true] = [0]
[0]
[split](x1) = [1 0] x1 + [1]
[1 2] [3]
[split#1](x1) = [1 0] x1 + [1]
[1 2] [3]
[#and](x1, x2) = [0]
[1]
[#EQ] = [0]
[0]
[#GT] = [0]
[0]
[#LT] = [0]
[0]
[#0] = [3]
[0]
[#neg](x1) = [1 0] x1 + [3]
[0 1] [0]
[#pos](x1) = [1 0] x1 + [3]
[0 1] [2]
[#s](x1) = [1 0] x1 + [3]
[0 1] [2]
[#equal^#](x1, x2) = [0]
[0]
[#eq^#](x1, x2) = [0]
[0]
[#greater^#](x1, x2) = [0]
[0]
[#ckgt^#](x1) = [0]
[0]
[#compare^#](x1, x2) = [0]
[0]
[append^#](x1, x2) = [0]
[0]
[append#1^#](x1, x2) = [0]
[0]
[insert^#](x1, x2) = [2 0] x2 + [2]
[0 0] [0]
[insert#1^#](x1, x2, x3) = [2 0] x2 + [2]
[0 0] [0]
[insert#2^#](x1, x2, x3, x4) = [2 0] x1 + [2]
[0 0] [0]
[insert#3^#](x1, x2, x3, x4, x5) = [2 0] x3 + [3]
[0 0] [0]
[insert#4^#](x1, x2, x3, x4, x5, x6) = [0 1] x1 + [2 0] x3 + [1]
[0 0] [0 0] [0]
[quicksort^#](x1) = [0]
[0]
[quicksort#1^#](x1) = [0]
[0]
[quicksort#2^#](x1, x2) = [0]
[0]
[splitqs^#](x1, x2) = [0]
[0]
[splitqs#1^#](x1, x2) = [0]
[0]
[sortAll^#](x1) = [0]
[0]
[sortAll#1^#](x1) = [0]
[0]
[sortAll#2^#](x1, x2) = [0]
[0]
[split^#](x1) = [3 3] x1 + [3]
[0 0] [0]
[split#1^#](x1) = [3 3] x1 + [2]
[0 0] [0]
[splitAndSort^#](x1) = [3 3] x1 + [3]
[3 3] [3]
[splitqs#2^#](x1, x2, x3) = [0]
[0]
[splitqs#3^#](x1, x2, x3, x4) = [0]
[0]
[#and^#](x1, x2) = [0]
[0]
[c_1](x1, x2) = [1 1] x1 + [1 1] x2 + [0]
[0 0] [0 0] [0]
This order satisfies following ordering constraints
[#equal(@x, @y)] = [0]
[2]
>= [0]
[2]
= [#eq(@x, @y)]
[#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [0]
[2]
>= [0]
[1]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(::(@x_1, @x_2), nil())] = [0]
[2]
>= [0]
[1]
= [#false()]
[#eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2))] = [0]
[2]
>= [0]
[1]
= [#false()]
[#eq(nil(), ::(@y_1, @y_2))] = [0]
[2]
>= [0]
[1]
= [#false()]
[#eq(nil(), nil())] = [0]
[2]
>= [0]
[0]
= [#true()]
[#eq(nil(), tuple#2(@y_1, @y_2))] = [0]
[2]
>= [0]
[1]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2))] = [0]
[2]
>= [0]
[1]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), nil())] = [0]
[2]
>= [0]
[1]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2))] = [0]
[2]
>= [0]
[1]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(#0(), #0())] = [0]
[2]
>= [0]
[0]
= [#true()]
[#eq(#0(), #neg(@y))] = [0]
[2]
>= [0]
[1]
= [#false()]
[#eq(#0(), #pos(@y))] = [0]
[2]
>= [0]
[1]
= [#false()]
[#eq(#0(), #s(@y))] = [0]
[2]
>= [0]
[1]
= [#false()]
[#eq(#neg(@x), #0())] = [0]
[2]
>= [0]
[1]
= [#false()]
[#eq(#neg(@x), #neg(@y))] = [0]
[2]
>= [0]
[2]
= [#eq(@x, @y)]
[#eq(#neg(@x), #pos(@y))] = [0]
[2]
>= [0]
[1]
= [#false()]
[#eq(#pos(@x), #0())] = [0]
[2]
>= [0]
[1]
= [#false()]
[#eq(#pos(@x), #neg(@y))] = [0]
[2]
>= [0]
[1]
= [#false()]
[#eq(#pos(@x), #pos(@y))] = [0]
[2]
>= [0]
[2]
= [#eq(@x, @y)]
[#eq(#s(@x), #0())] = [0]
[2]
>= [0]
[1]
= [#false()]
[#eq(#s(@x), #s(@y))] = [0]
[2]
>= [0]
[2]
= [#eq(@x, @y)]
[insert(@x, @l)] = [1 0] @l + [1]
[2 1] [1]
>= [1 0] @l + [1]
[2 1] [1]
= [insert#1(@x, @l, @x)]
[insert#1(tuple#2(@valX, @keyX), @l, @x)] = [1 0] @l + [1]
[2 1] [1]
>= [1 0] @l + [1]
[2 1] [1]
= [insert#2(@l, @keyX, @valX, @x)]
[insert#2(::(@l1, @ls), @keyX, @valX, @x)] = [0 0] @l1 + [1 0] @ls + [2]
[1 1] [3 1] [4]
>= [0 0] @l1 + [1 0] @ls + [2]
[1 1] [3 1] [3]
= [insert#3(@l1, @keyX, @ls, @valX, @x)]
[insert#2(nil(), @keyX, @valX, @x)] = [1]
[1]
>= [1]
[1]
= [::(tuple#2(::(@valX, nil()), @keyX), nil())]
[insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x)] = [1 0] @ls + [2]
[3 1] [3]
>= [1 0] @ls + [2]
[3 1] [3]
= [insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)]
[insert#4(#false(), @key1, @ls, @valX, @vals1, @x)] = [1 0] @ls + [2]
[3 1] [3]
>= [1 0] @ls + [2]
[3 1] [3]
= [::(tuple#2(@vals1, @key1), insert(@x, @ls))]
[insert#4(#true(), @key1, @ls, @valX, @vals1, @x)] = [1 0] @ls + [2]
[3 1] [3]
> [1 0] @ls + [1]
[1 1] [1]
= [::(tuple#2(::(@valX, @vals1), @key1), @ls)]
[split(@l)] = [1 0] @l + [1]
[1 2] [3]
>= [1 0] @l + [1]
[1 2] [3]
= [split#1(@l)]
[split#1(::(@x, @xs))] = [0 0] @x + [1 0] @xs + [2]
[2 2] [3 2] [6]
>= [1 0] @xs + [2]
[3 2] [6]
= [insert(@x, split(@xs))]
[split#1(nil())] = [1]
[3]
> [0]
[0]
= [nil()]
[#and(#false(), #false())] = [0]
[1]
>= [0]
[1]
= [#false()]
[#and(#false(), #true())] = [0]
[1]
>= [0]
[1]
= [#false()]
[#and(#true(), #false())] = [0]
[1]
>= [0]
[1]
= [#false()]
[#and(#true(), #true())] = [0]
[1]
>= [0]
[0]
= [#true()]
[insert^#(@x, @l)] = [2 0] @l + [2]
[0 0] [0]
>= [2 0] @l + [2]
[0 0] [0]
= [insert#1^#(@x, @l, @x)]
[insert#1^#(tuple#2(@valX, @keyX), @l, @x)] = [2 0] @l + [2]
[0 0] [0]
>= [2 0] @l + [2]
[0 0] [0]
= [insert#2^#(@l, @keyX, @valX, @x)]
[insert#2^#(::(@l1, @ls), @keyX, @valX, @x)] = [2 0] @ls + [4]
[0 0] [0]
> [2 0] @ls + [3]
[0 0] [0]
= [insert#3^#(@l1, @keyX, @ls, @valX, @x)]
[insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x)] = [2 0] @ls + [3]
[0 0] [0]
>= [2 0] @ls + [3]
[0 0] [0]
= [insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)]
[insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x)] = [2 0] @ls + [2]
[0 0] [0]
>= [2 0] @ls + [2]
[0 0] [0]
= [insert^#(@x, @ls)]
[split^#(@l)] = [3 3] @l + [3]
[0 0] [0]
> [3 3] @l + [2]
[0 0] [0]
= [split#1^#(@l)]
[split#1^#(::(@x, @xs))] = [3 3] @x + [6 3] @xs + [8]
[0 0] [0 0] [0]
> [5 3] @xs + [7]
[0 0] [0]
= [c_1(insert^#(@x, split(@xs)), split^#(@xs))]
[splitAndSort^#(@l)] = [3 3] @l + [3]
[3 3] [3]
>= [3 3] @l + [3]
[0 0] [0]
= [split^#(@l)]
Processor 'matrix interpretation of dimension 2' induces the
complexity certificate YES(?,O(n^2)) on application of rules
{2,4,7}. Here rules are labeled according to the (estimated)
dependency graph
1: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
-->_1 insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x) :3
2: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) ->
c_1(insert^#(@x, split(@xs)), split^#(@xs)) :7
3: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
-->_1 insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x) :4
4: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
-->_1 insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x) :5
5: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
-->_1 insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) :6
6: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
7: split#1^#(::(@x, @xs)) ->
c_1(insert^#(@x, split(@xs)), split^#(@xs))
-->_2 split^#(@l) -> split#1^#(@l) :2
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
8: splitAndSort^#(@l) -> split^#(@l)
-->_1 split^#(@l) -> split#1^#(@l) :2
- The rules {2,4,7} have known complexity. These cover all
predecessors of {5,8}, their complexity is equally bounded.
- The rules {2,4,5,7,8} have known complexity. These cover all
predecessors of {6}, their complexity is equally bounded.
- The rules {2,4,5,6,7,8} have known complexity. These cover all
predecessors of {1}, their complexity is equally bounded.
- The rules {1,2,4,5,6,7,8} have known complexity. These cover all
predecessors of {3}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules
{1,2,3,4,5,6,7,8} is given by YES(?,O(n^2)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_1(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> split^#(@l) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{8} Weak SCC
|
`->2:{6,7} Weak SCC
|
`->3:{1,5,4,3,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, 2: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, 3: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, 4: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, 5: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, 6: split^#(@l) -> split#1^#(@l)
, 7: split#1^#(::(@x, @xs)) ->
c_1(insert^#(@x, split(@xs)), split^#(@xs))
, 8: splitAndSort^#(@l) -> split^#(@l) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 8: splitAndSort^#(@l) -> split^#(@l)
, 6: split^#(@l) -> split#1^#(@l)
, 7: split#1^#(::(@x, @xs)) ->
c_1(insert^#(@x, split(@xs)), split^#(@xs))
, 1: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, 5: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, 4: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, 3: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, 2: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x) }
We apply the transformation 'usablerules' on the sub-problem:
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
No rule is usable.
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
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
Arrrr..
tct-popstar
MAYBE
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs)) }
Weak Trs:
{ #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We add following dependency tuples
Strict DPs:
{ #equal^#(@x, @y) -> #eq^#(@x, @y)
, #greater^#(@x, @y) ->
c_2(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y))
, append^#(@l, @ys) -> append#1^#(@l, @ys)
, append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, append#1^#(nil(), @ys) -> c_5()
, insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#2^#(nil(), @keyX, @valX, @x) -> c_9()
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX))
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) -> c_12()
, quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_14(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#1^#(nil()) -> c_15()
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_17(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs))
, splitqs#1^#(nil(), @pivot) -> c_27()
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#1^#(nil()) -> c_20()
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_21(quicksort^#(@vals), sortAll^#(@xs))
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_23(insert^#(@x, split(@xs)), split^#(@xs))
, split#1^#(nil()) -> c_24()
, splitAndSort^#(@l) -> c_25(sortAll^#(split(@l)), split^#(@l))
, splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
#greater^#(@x, @pivot))
, splitqs#3^#(#false(), @ls, @rs, @x) -> c_29()
, splitqs#3^#(#true(), @ls, @rs, @x) -> c_30() }
Weak DPs:
{ #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, #eq^#(::(@x_1, @x_2), nil()) -> c_32()
, #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33()
, #eq^#(nil(), ::(@y_1, @y_2)) -> c_34()
, #eq^#(nil(), nil()) -> c_35()
, #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36()
, #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37()
, #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38()
, #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, #eq^#(#0(), #0()) -> c_40()
, #eq^#(#0(), #neg(@y)) -> c_41()
, #eq^#(#0(), #pos(@y)) -> c_42()
, #eq^#(#0(), #s(@y)) -> c_43()
, #eq^#(#neg(@x), #0()) -> c_44()
, #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y)
, #eq^#(#neg(@x), #pos(@y)) -> c_46()
, #eq^#(#pos(@x), #0()) -> c_47()
, #eq^#(#pos(@x), #neg(@y)) -> c_48()
, #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y)
, #eq^#(#s(@x), #0()) -> c_50()
, #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y)
, #ckgt^#(#EQ()) -> c_64()
, #ckgt^#(#GT()) -> c_65()
, #ckgt^#(#LT()) -> c_66()
, #compare^#(#0(), #0()) -> c_52()
, #compare^#(#0(), #neg(@y)) -> c_53()
, #compare^#(#0(), #pos(@y)) -> c_54()
, #compare^#(#0(), #s(@y)) -> c_55()
, #compare^#(#neg(@x), #0()) -> c_56()
, #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x)
, #compare^#(#neg(@x), #pos(@y)) -> c_58()
, #compare^#(#pos(@x), #0()) -> c_59()
, #compare^#(#pos(@x), #neg(@y)) -> c_60()
, #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y)
, #compare^#(#s(@x), #0()) -> c_62()
, #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y)
, #and^#(#false(), #false()) -> c_67()
, #and^#(#false(), #true()) -> c_68()
, #and^#(#true(), #false()) -> c_69()
, #and^#(#true(), #true()) -> c_70() }
and replace the set of basic marked basic terms accordingly.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ #equal^#(@x, @y) -> #eq^#(@x, @y)
, #greater^#(@x, @y) ->
c_2(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y))
, append^#(@l, @ys) -> append#1^#(@l, @ys)
, append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, append#1^#(nil(), @ys) -> c_5()
, insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#2^#(nil(), @keyX, @valX, @x) -> c_9()
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX))
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) -> c_12()
, quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_14(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#1^#(nil()) -> c_15()
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_17(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs))
, splitqs#1^#(nil(), @pivot) -> c_27()
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#1^#(nil()) -> c_20()
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_21(quicksort^#(@vals), sortAll^#(@xs))
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_23(insert^#(@x, split(@xs)), split^#(@xs))
, split#1^#(nil()) -> c_24()
, splitAndSort^#(@l) -> c_25(sortAll^#(split(@l)), split^#(@l))
, splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
#greater^#(@x, @pivot))
, splitqs#3^#(#false(), @ls, @rs, @x) -> c_29()
, splitqs#3^#(#true(), @ls, @rs, @x) -> c_30() }
Weak DPs:
{ #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, #eq^#(::(@x_1, @x_2), nil()) -> c_32()
, #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33()
, #eq^#(nil(), ::(@y_1, @y_2)) -> c_34()
, #eq^#(nil(), nil()) -> c_35()
, #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36()
, #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37()
, #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38()
, #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, #eq^#(#0(), #0()) -> c_40()
, #eq^#(#0(), #neg(@y)) -> c_41()
, #eq^#(#0(), #pos(@y)) -> c_42()
, #eq^#(#0(), #s(@y)) -> c_43()
, #eq^#(#neg(@x), #0()) -> c_44()
, #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y)
, #eq^#(#neg(@x), #pos(@y)) -> c_46()
, #eq^#(#pos(@x), #0()) -> c_47()
, #eq^#(#pos(@x), #neg(@y)) -> c_48()
, #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y)
, #eq^#(#s(@x), #0()) -> c_50()
, #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y)
, #ckgt^#(#EQ()) -> c_64()
, #ckgt^#(#GT()) -> c_65()
, #ckgt^#(#LT()) -> c_66()
, #compare^#(#0(), #0()) -> c_52()
, #compare^#(#0(), #neg(@y)) -> c_53()
, #compare^#(#0(), #pos(@y)) -> c_54()
, #compare^#(#0(), #s(@y)) -> c_55()
, #compare^#(#neg(@x), #0()) -> c_56()
, #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x)
, #compare^#(#neg(@x), #pos(@y)) -> c_58()
, #compare^#(#pos(@x), #0()) -> c_59()
, #compare^#(#pos(@x), #neg(@y)) -> c_60()
, #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y)
, #compare^#(#s(@x), #0()) -> c_62()
, #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y)
, #and^#(#false(), #false()) -> c_67()
, #and^#(#false(), #true()) -> c_68()
, #and^#(#true(), #false()) -> c_69()
, #and^#(#true(), #true()) -> c_70() }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: #equal^#(@x, @y) -> #eq^#(@x, @y)
-->_1 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :51
-->_1 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :49
-->_1 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :45
-->_1 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :39
-->_1 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :31
-->_1 #eq^#(#s(@x), #0()) -> c_50() :50
-->_1 #eq^#(#pos(@x), #neg(@y)) -> c_48() :48
-->_1 #eq^#(#pos(@x), #0()) -> c_47() :47
-->_1 #eq^#(#neg(@x), #pos(@y)) -> c_46() :46
-->_1 #eq^#(#neg(@x), #0()) -> c_44() :44
-->_1 #eq^#(#0(), #s(@y)) -> c_43() :43
-->_1 #eq^#(#0(), #pos(@y)) -> c_42() :42
-->_1 #eq^#(#0(), #neg(@y)) -> c_41() :41
-->_1 #eq^#(#0(), #0()) -> c_40() :40
-->_1 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :38
-->_1 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :37
-->_1 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :36
-->_1 #eq^#(nil(), nil()) -> c_35() :35
-->_1 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :34
-->_1 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :33
-->_1 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :32
2: #greater^#(@x, @y) ->
c_2(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y))
-->_2 #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y) :66
-->_2 #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y) :64
-->_2 #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x) :60
-->_2 #compare^#(#s(@x), #0()) -> c_62() :65
-->_2 #compare^#(#pos(@x), #neg(@y)) -> c_60() :63
-->_2 #compare^#(#pos(@x), #0()) -> c_59() :62
-->_2 #compare^#(#neg(@x), #pos(@y)) -> c_58() :61
-->_2 #compare^#(#neg(@x), #0()) -> c_56() :59
-->_2 #compare^#(#0(), #s(@y)) -> c_55() :58
-->_2 #compare^#(#0(), #pos(@y)) -> c_54() :57
-->_2 #compare^#(#0(), #neg(@y)) -> c_53() :56
-->_2 #compare^#(#0(), #0()) -> c_52() :55
-->_1 #ckgt^#(#LT()) -> c_66() :54
-->_1 #ckgt^#(#GT()) -> c_65() :53
-->_1 #ckgt^#(#EQ()) -> c_64() :52
3: append^#(@l, @ys) -> append#1^#(@l, @ys)
-->_1 append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys) :4
-->_1 append#1^#(nil(), @ys) -> c_5() :5
4: append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :3
5: append#1^#(nil(), @ys) -> c_5()
6: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
-->_1 insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x) :7
7: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
-->_1 insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x) :8
-->_1 insert#2^#(nil(), @keyX, @valX, @x) -> c_9() :9
8: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
-->_1 insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX)) :10
9: insert#2^#(nil(), @keyX, @valX, @x) -> c_9()
10: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX))
-->_1 insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) :11
-->_1 insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) ->
c_12() :12
-->_2 #equal^#(@x, @y) -> #eq^#(@x, @y) :1
11: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :6
12: insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) -> c_12()
13: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_14(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :14
-->_1 quicksort#1^#(nil()) -> c_15() :15
14: quicksort#1^#(::(@z, @zs)) ->
c_14(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :17
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_17(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :16
15: quicksort#1^#(nil()) -> c_15()
16: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_17(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :13
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :13
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :3
17: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
-->_1 splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs)) :18
-->_1 splitqs#1^#(nil(), @pivot) -> c_27() :19
18: splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs))
-->_1 splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
#greater^#(@x, @pivot)) :28
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :17
19: splitqs#1^#(nil(), @pivot) -> c_27()
20: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :21
-->_1 sortAll#1^#(nil()) -> c_20() :22
21: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_21(quicksort^#(@vals), sortAll^#(@xs)) :23
22: sortAll#1^#(nil()) -> c_20()
23: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_21(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :20
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :13
24: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) ->
c_23(insert^#(@x, split(@xs)), split^#(@xs)) :25
-->_1 split#1^#(nil()) -> c_24() :26
25: split#1^#(::(@x, @xs)) ->
c_23(insert^#(@x, split(@xs)), split^#(@xs))
-->_2 split^#(@l) -> split#1^#(@l) :24
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :6
26: split#1^#(nil()) -> c_24()
27: splitAndSort^#(@l) -> c_25(sortAll^#(split(@l)), split^#(@l))
-->_2 split^#(@l) -> split#1^#(@l) :24
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :20
28: splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
#greater^#(@x, @pivot))
-->_1 splitqs#3^#(#true(), @ls, @rs, @x) -> c_30() :30
-->_1 splitqs#3^#(#false(), @ls, @rs, @x) -> c_29() :29
-->_2 #greater^#(@x, @y) ->
c_2(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y)) :2
29: splitqs#3^#(#false(), @ls, @rs, @x) -> c_29()
30: splitqs#3^#(#true(), @ls, @rs, @x) -> c_30()
31: #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
-->_3 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :51
-->_2 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :51
-->_3 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :49
-->_2 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :49
-->_3 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :45
-->_2 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :45
-->_3 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :39
-->_2 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :39
-->_1 #and^#(#true(), #true()) -> c_70() :70
-->_1 #and^#(#true(), #false()) -> c_69() :69
-->_1 #and^#(#false(), #true()) -> c_68() :68
-->_1 #and^#(#false(), #false()) -> c_67() :67
-->_3 #eq^#(#s(@x), #0()) -> c_50() :50
-->_2 #eq^#(#s(@x), #0()) -> c_50() :50
-->_3 #eq^#(#pos(@x), #neg(@y)) -> c_48() :48
-->_2 #eq^#(#pos(@x), #neg(@y)) -> c_48() :48
-->_3 #eq^#(#pos(@x), #0()) -> c_47() :47
-->_2 #eq^#(#pos(@x), #0()) -> c_47() :47
-->_3 #eq^#(#neg(@x), #pos(@y)) -> c_46() :46
-->_2 #eq^#(#neg(@x), #pos(@y)) -> c_46() :46
-->_3 #eq^#(#neg(@x), #0()) -> c_44() :44
-->_2 #eq^#(#neg(@x), #0()) -> c_44() :44
-->_3 #eq^#(#0(), #s(@y)) -> c_43() :43
-->_2 #eq^#(#0(), #s(@y)) -> c_43() :43
-->_3 #eq^#(#0(), #pos(@y)) -> c_42() :42
-->_2 #eq^#(#0(), #pos(@y)) -> c_42() :42
-->_3 #eq^#(#0(), #neg(@y)) -> c_41() :41
-->_2 #eq^#(#0(), #neg(@y)) -> c_41() :41
-->_3 #eq^#(#0(), #0()) -> c_40() :40
-->_2 #eq^#(#0(), #0()) -> c_40() :40
-->_3 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :38
-->_2 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :38
-->_3 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :37
-->_2 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :37
-->_3 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :36
-->_2 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :36
-->_3 #eq^#(nil(), nil()) -> c_35() :35
-->_2 #eq^#(nil(), nil()) -> c_35() :35
-->_3 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :34
-->_2 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :34
-->_3 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :33
-->_2 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :33
-->_3 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :32
-->_2 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :32
-->_3 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :31
-->_2 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :31
32: #eq^#(::(@x_1, @x_2), nil()) -> c_32()
33: #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33()
34: #eq^#(nil(), ::(@y_1, @y_2)) -> c_34()
35: #eq^#(nil(), nil()) -> c_35()
36: #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36()
37: #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37()
38: #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38()
39: #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
-->_3 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :51
-->_2 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :51
-->_3 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :49
-->_2 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :49
-->_3 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :45
-->_2 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :45
-->_1 #and^#(#true(), #true()) -> c_70() :70
-->_1 #and^#(#true(), #false()) -> c_69() :69
-->_1 #and^#(#false(), #true()) -> c_68() :68
-->_1 #and^#(#false(), #false()) -> c_67() :67
-->_3 #eq^#(#s(@x), #0()) -> c_50() :50
-->_2 #eq^#(#s(@x), #0()) -> c_50() :50
-->_3 #eq^#(#pos(@x), #neg(@y)) -> c_48() :48
-->_2 #eq^#(#pos(@x), #neg(@y)) -> c_48() :48
-->_3 #eq^#(#pos(@x), #0()) -> c_47() :47
-->_2 #eq^#(#pos(@x), #0()) -> c_47() :47
-->_3 #eq^#(#neg(@x), #pos(@y)) -> c_46() :46
-->_2 #eq^#(#neg(@x), #pos(@y)) -> c_46() :46
-->_3 #eq^#(#neg(@x), #0()) -> c_44() :44
-->_2 #eq^#(#neg(@x), #0()) -> c_44() :44
-->_3 #eq^#(#0(), #s(@y)) -> c_43() :43
-->_2 #eq^#(#0(), #s(@y)) -> c_43() :43
-->_3 #eq^#(#0(), #pos(@y)) -> c_42() :42
-->_2 #eq^#(#0(), #pos(@y)) -> c_42() :42
-->_3 #eq^#(#0(), #neg(@y)) -> c_41() :41
-->_2 #eq^#(#0(), #neg(@y)) -> c_41() :41
-->_3 #eq^#(#0(), #0()) -> c_40() :40
-->_2 #eq^#(#0(), #0()) -> c_40() :40
-->_3 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :39
-->_2 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :39
-->_3 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :38
-->_2 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :38
-->_3 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :37
-->_2 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :37
-->_3 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :36
-->_2 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :36
-->_3 #eq^#(nil(), nil()) -> c_35() :35
-->_2 #eq^#(nil(), nil()) -> c_35() :35
-->_3 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :34
-->_2 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :34
-->_3 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :33
-->_2 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :33
-->_3 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :32
-->_2 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :32
-->_3 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :31
-->_2 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :31
40: #eq^#(#0(), #0()) -> c_40()
41: #eq^#(#0(), #neg(@y)) -> c_41()
42: #eq^#(#0(), #pos(@y)) -> c_42()
43: #eq^#(#0(), #s(@y)) -> c_43()
44: #eq^#(#neg(@x), #0()) -> c_44()
45: #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y)
-->_1 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :51
-->_1 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :49
-->_1 #eq^#(#s(@x), #0()) -> c_50() :50
-->_1 #eq^#(#pos(@x), #neg(@y)) -> c_48() :48
-->_1 #eq^#(#pos(@x), #0()) -> c_47() :47
-->_1 #eq^#(#neg(@x), #pos(@y)) -> c_46() :46
-->_1 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :45
-->_1 #eq^#(#neg(@x), #0()) -> c_44() :44
-->_1 #eq^#(#0(), #s(@y)) -> c_43() :43
-->_1 #eq^#(#0(), #pos(@y)) -> c_42() :42
-->_1 #eq^#(#0(), #neg(@y)) -> c_41() :41
-->_1 #eq^#(#0(), #0()) -> c_40() :40
-->_1 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :39
-->_1 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :38
-->_1 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :37
-->_1 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :36
-->_1 #eq^#(nil(), nil()) -> c_35() :35
-->_1 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :34
-->_1 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :33
-->_1 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :32
-->_1 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :31
46: #eq^#(#neg(@x), #pos(@y)) -> c_46()
47: #eq^#(#pos(@x), #0()) -> c_47()
48: #eq^#(#pos(@x), #neg(@y)) -> c_48()
49: #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y)
-->_1 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :51
-->_1 #eq^#(#s(@x), #0()) -> c_50() :50
-->_1 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :49
-->_1 #eq^#(#pos(@x), #neg(@y)) -> c_48() :48
-->_1 #eq^#(#pos(@x), #0()) -> c_47() :47
-->_1 #eq^#(#neg(@x), #pos(@y)) -> c_46() :46
-->_1 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :45
-->_1 #eq^#(#neg(@x), #0()) -> c_44() :44
-->_1 #eq^#(#0(), #s(@y)) -> c_43() :43
-->_1 #eq^#(#0(), #pos(@y)) -> c_42() :42
-->_1 #eq^#(#0(), #neg(@y)) -> c_41() :41
-->_1 #eq^#(#0(), #0()) -> c_40() :40
-->_1 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :39
-->_1 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :38
-->_1 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :37
-->_1 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :36
-->_1 #eq^#(nil(), nil()) -> c_35() :35
-->_1 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :34
-->_1 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :33
-->_1 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :32
-->_1 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :31
50: #eq^#(#s(@x), #0()) -> c_50()
51: #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y)
-->_1 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :51
-->_1 #eq^#(#s(@x), #0()) -> c_50() :50
-->_1 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :49
-->_1 #eq^#(#pos(@x), #neg(@y)) -> c_48() :48
-->_1 #eq^#(#pos(@x), #0()) -> c_47() :47
-->_1 #eq^#(#neg(@x), #pos(@y)) -> c_46() :46
-->_1 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :45
-->_1 #eq^#(#neg(@x), #0()) -> c_44() :44
-->_1 #eq^#(#0(), #s(@y)) -> c_43() :43
-->_1 #eq^#(#0(), #pos(@y)) -> c_42() :42
-->_1 #eq^#(#0(), #neg(@y)) -> c_41() :41
-->_1 #eq^#(#0(), #0()) -> c_40() :40
-->_1 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :39
-->_1 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :38
-->_1 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :37
-->_1 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :36
-->_1 #eq^#(nil(), nil()) -> c_35() :35
-->_1 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :34
-->_1 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :33
-->_1 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :32
-->_1 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :31
52: #ckgt^#(#EQ()) -> c_64()
53: #ckgt^#(#GT()) -> c_65()
54: #ckgt^#(#LT()) -> c_66()
55: #compare^#(#0(), #0()) -> c_52()
56: #compare^#(#0(), #neg(@y)) -> c_53()
57: #compare^#(#0(), #pos(@y)) -> c_54()
58: #compare^#(#0(), #s(@y)) -> c_55()
59: #compare^#(#neg(@x), #0()) -> c_56()
60: #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x)
-->_1 #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y) :66
-->_1 #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y) :64
-->_1 #compare^#(#s(@x), #0()) -> c_62() :65
-->_1 #compare^#(#pos(@x), #neg(@y)) -> c_60() :63
-->_1 #compare^#(#pos(@x), #0()) -> c_59() :62
-->_1 #compare^#(#neg(@x), #pos(@y)) -> c_58() :61
-->_1 #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x) :60
-->_1 #compare^#(#neg(@x), #0()) -> c_56() :59
-->_1 #compare^#(#0(), #s(@y)) -> c_55() :58
-->_1 #compare^#(#0(), #pos(@y)) -> c_54() :57
-->_1 #compare^#(#0(), #neg(@y)) -> c_53() :56
-->_1 #compare^#(#0(), #0()) -> c_52() :55
61: #compare^#(#neg(@x), #pos(@y)) -> c_58()
62: #compare^#(#pos(@x), #0()) -> c_59()
63: #compare^#(#pos(@x), #neg(@y)) -> c_60()
64: #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y)
-->_1 #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y) :66
-->_1 #compare^#(#s(@x), #0()) -> c_62() :65
-->_1 #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y) :64
-->_1 #compare^#(#pos(@x), #neg(@y)) -> c_60() :63
-->_1 #compare^#(#pos(@x), #0()) -> c_59() :62
-->_1 #compare^#(#neg(@x), #pos(@y)) -> c_58() :61
-->_1 #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x) :60
-->_1 #compare^#(#neg(@x), #0()) -> c_56() :59
-->_1 #compare^#(#0(), #s(@y)) -> c_55() :58
-->_1 #compare^#(#0(), #pos(@y)) -> c_54() :57
-->_1 #compare^#(#0(), #neg(@y)) -> c_53() :56
-->_1 #compare^#(#0(), #0()) -> c_52() :55
65: #compare^#(#s(@x), #0()) -> c_62()
66: #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y)
-->_1 #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y) :66
-->_1 #compare^#(#s(@x), #0()) -> c_62() :65
-->_1 #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y) :64
-->_1 #compare^#(#pos(@x), #neg(@y)) -> c_60() :63
-->_1 #compare^#(#pos(@x), #0()) -> c_59() :62
-->_1 #compare^#(#neg(@x), #pos(@y)) -> c_58() :61
-->_1 #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x) :60
-->_1 #compare^#(#neg(@x), #0()) -> c_56() :59
-->_1 #compare^#(#0(), #s(@y)) -> c_55() :58
-->_1 #compare^#(#0(), #pos(@y)) -> c_54() :57
-->_1 #compare^#(#0(), #neg(@y)) -> c_53() :56
-->_1 #compare^#(#0(), #0()) -> c_52() :55
67: #and^#(#false(), #false()) -> c_67()
68: #and^#(#false(), #true()) -> c_68()
69: #and^#(#true(), #false()) -> c_69()
70: #and^#(#true(), #true()) -> c_70()
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {26} and add Pre({26}) = {24} to the strict component.
- We remove {22} and add Pre({22}) = {20} to the strict component.
- We remove {15} and add Pre({15}) = {13} to the strict component.
- We remove {19} and add Pre({19}) = {17} to the strict component.
- We remove {29} and add Pre({29}) = {28} to the strict component.
- We remove {30} and add Pre({30}) = {28} to the strict component.
- We remove {9} and add Pre({9}) = {7} to the strict component.
- We remove {12} and add Pre({12}) = {10} to the strict component.
- We remove {5} and add Pre({5}) = {3} to the strict component.
- We remove {2} and add Pre({2}) = {28} to the strict component.
- We remove {1} and add Pre({1}) = {10} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX))
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_14(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_17(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_21(quicksort^#(@vals), sortAll^#(@xs))
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_23(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> c_25(sortAll^#(split(@l)), split^#(@l))
, splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
#greater^#(@x, @pivot)) }
Weak DPs:
{ #equal^#(@x, @y) -> #eq^#(@x, @y)
, #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, #eq^#(::(@x_1, @x_2), nil()) -> c_32()
, #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33()
, #eq^#(nil(), ::(@y_1, @y_2)) -> c_34()
, #eq^#(nil(), nil()) -> c_35()
, #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36()
, #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37()
, #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38()
, #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, #eq^#(#0(), #0()) -> c_40()
, #eq^#(#0(), #neg(@y)) -> c_41()
, #eq^#(#0(), #pos(@y)) -> c_42()
, #eq^#(#0(), #s(@y)) -> c_43()
, #eq^#(#neg(@x), #0()) -> c_44()
, #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y)
, #eq^#(#neg(@x), #pos(@y)) -> c_46()
, #eq^#(#pos(@x), #0()) -> c_47()
, #eq^#(#pos(@x), #neg(@y)) -> c_48()
, #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y)
, #eq^#(#s(@x), #0()) -> c_50()
, #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y)
, #greater^#(@x, @y) ->
c_2(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y))
, #ckgt^#(#EQ()) -> c_64()
, #ckgt^#(#GT()) -> c_65()
, #ckgt^#(#LT()) -> c_66()
, #compare^#(#0(), #0()) -> c_52()
, #compare^#(#0(), #neg(@y)) -> c_53()
, #compare^#(#0(), #pos(@y)) -> c_54()
, #compare^#(#0(), #s(@y)) -> c_55()
, #compare^#(#neg(@x), #0()) -> c_56()
, #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x)
, #compare^#(#neg(@x), #pos(@y)) -> c_58()
, #compare^#(#pos(@x), #0()) -> c_59()
, #compare^#(#pos(@x), #neg(@y)) -> c_60()
, #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y)
, #compare^#(#s(@x), #0()) -> c_62()
, #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y)
, append#1^#(nil(), @ys) -> c_5()
, insert#2^#(nil(), @keyX, @valX, @x) -> c_9()
, insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) -> c_12()
, quicksort#1^#(nil()) -> c_15()
, splitqs#1^#(nil(), @pivot) -> c_27()
, sortAll#1^#(nil()) -> c_20()
, split#1^#(nil()) -> c_24()
, splitqs#3^#(#false(), @ls, @rs, @x) -> c_29()
, splitqs#3^#(#true(), @ls, @rs, @x) -> c_30()
, #and^#(#false(), #false()) -> c_67()
, #and^#(#false(), #true()) -> c_68()
, #and^#(#true(), #false()) -> c_69()
, #and^#(#true(), #true()) -> c_70() }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append^#(@l, @ys) -> append#1^#(@l, @ys)
-->_1 append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys) :2
-->_1 append#1^#(nil(), @ys) -> c_5() :58
2: append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
3: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
-->_1 insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x) :4
4: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
-->_1 insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x) :5
-->_1 insert#2^#(nil(), @keyX, @valX, @x) -> c_9() :59
5: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
-->_1 insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX)) :6
6: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX))
-->_2 #equal^#(@x, @y) -> #eq^#(@x, @y) :20
-->_1 insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) :7
-->_1 insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) ->
c_12() :60
7: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :3
8: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_14(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :9
-->_1 quicksort#1^#(nil()) -> c_15() :61
9: quicksort#1^#(::(@z, @zs)) ->
c_14(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :11
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_17(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :10
10: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_17(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :8
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :8
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
11: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
-->_1 splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs)) :12
-->_1 splitqs#1^#(nil(), @pivot) -> c_27() :62
12: splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs))
-->_1 splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
#greater^#(@x, @pivot)) :19
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :11
13: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :14
-->_1 sortAll#1^#(nil()) -> c_20() :63
14: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_21(quicksort^#(@vals), sortAll^#(@xs)) :15
15: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_21(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :13
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :8
16: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) ->
c_23(insert^#(@x, split(@xs)), split^#(@xs)) :17
-->_1 split#1^#(nil()) -> c_24() :64
17: split#1^#(::(@x, @xs)) ->
c_23(insert^#(@x, split(@xs)), split^#(@xs))
-->_2 split^#(@l) -> split#1^#(@l) :16
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :3
18: splitAndSort^#(@l) -> c_25(sortAll^#(split(@l)), split^#(@l))
-->_2 split^#(@l) -> split#1^#(@l) :16
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :13
19: splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
#greater^#(@x, @pivot))
-->_2 #greater^#(@x, @y) ->
c_2(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y)) :42
-->_1 splitqs#3^#(#true(), @ls, @rs, @x) -> c_30() :66
-->_1 splitqs#3^#(#false(), @ls, @rs, @x) -> c_29() :65
20: #equal^#(@x, @y) -> #eq^#(@x, @y)
-->_1 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :41
-->_1 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :39
-->_1 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :35
-->_1 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :29
-->_1 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :21
-->_1 #eq^#(#s(@x), #0()) -> c_50() :40
-->_1 #eq^#(#pos(@x), #neg(@y)) -> c_48() :38
-->_1 #eq^#(#pos(@x), #0()) -> c_47() :37
-->_1 #eq^#(#neg(@x), #pos(@y)) -> c_46() :36
-->_1 #eq^#(#neg(@x), #0()) -> c_44() :34
-->_1 #eq^#(#0(), #s(@y)) -> c_43() :33
-->_1 #eq^#(#0(), #pos(@y)) -> c_42() :32
-->_1 #eq^#(#0(), #neg(@y)) -> c_41() :31
-->_1 #eq^#(#0(), #0()) -> c_40() :30
-->_1 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :28
-->_1 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :27
-->_1 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :26
-->_1 #eq^#(nil(), nil()) -> c_35() :25
-->_1 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :24
-->_1 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :23
-->_1 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :22
21: #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
-->_3 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :41
-->_2 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :41
-->_3 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :39
-->_2 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :39
-->_3 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :35
-->_2 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :35
-->_3 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :29
-->_2 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :29
-->_1 #and^#(#true(), #true()) -> c_70() :70
-->_1 #and^#(#true(), #false()) -> c_69() :69
-->_1 #and^#(#false(), #true()) -> c_68() :68
-->_1 #and^#(#false(), #false()) -> c_67() :67
-->_3 #eq^#(#s(@x), #0()) -> c_50() :40
-->_2 #eq^#(#s(@x), #0()) -> c_50() :40
-->_3 #eq^#(#pos(@x), #neg(@y)) -> c_48() :38
-->_2 #eq^#(#pos(@x), #neg(@y)) -> c_48() :38
-->_3 #eq^#(#pos(@x), #0()) -> c_47() :37
-->_2 #eq^#(#pos(@x), #0()) -> c_47() :37
-->_3 #eq^#(#neg(@x), #pos(@y)) -> c_46() :36
-->_2 #eq^#(#neg(@x), #pos(@y)) -> c_46() :36
-->_3 #eq^#(#neg(@x), #0()) -> c_44() :34
-->_2 #eq^#(#neg(@x), #0()) -> c_44() :34
-->_3 #eq^#(#0(), #s(@y)) -> c_43() :33
-->_2 #eq^#(#0(), #s(@y)) -> c_43() :33
-->_3 #eq^#(#0(), #pos(@y)) -> c_42() :32
-->_2 #eq^#(#0(), #pos(@y)) -> c_42() :32
-->_3 #eq^#(#0(), #neg(@y)) -> c_41() :31
-->_2 #eq^#(#0(), #neg(@y)) -> c_41() :31
-->_3 #eq^#(#0(), #0()) -> c_40() :30
-->_2 #eq^#(#0(), #0()) -> c_40() :30
-->_3 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :28
-->_2 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :28
-->_3 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :27
-->_2 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :27
-->_3 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :26
-->_2 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :26
-->_3 #eq^#(nil(), nil()) -> c_35() :25
-->_2 #eq^#(nil(), nil()) -> c_35() :25
-->_3 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :24
-->_2 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :24
-->_3 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :23
-->_2 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :23
-->_3 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :22
-->_2 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :22
-->_3 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :21
-->_2 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :21
22: #eq^#(::(@x_1, @x_2), nil()) -> c_32()
23: #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33()
24: #eq^#(nil(), ::(@y_1, @y_2)) -> c_34()
25: #eq^#(nil(), nil()) -> c_35()
26: #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36()
27: #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37()
28: #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38()
29: #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
-->_3 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :41
-->_2 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :41
-->_3 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :39
-->_2 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :39
-->_3 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :35
-->_2 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :35
-->_1 #and^#(#true(), #true()) -> c_70() :70
-->_1 #and^#(#true(), #false()) -> c_69() :69
-->_1 #and^#(#false(), #true()) -> c_68() :68
-->_1 #and^#(#false(), #false()) -> c_67() :67
-->_3 #eq^#(#s(@x), #0()) -> c_50() :40
-->_2 #eq^#(#s(@x), #0()) -> c_50() :40
-->_3 #eq^#(#pos(@x), #neg(@y)) -> c_48() :38
-->_2 #eq^#(#pos(@x), #neg(@y)) -> c_48() :38
-->_3 #eq^#(#pos(@x), #0()) -> c_47() :37
-->_2 #eq^#(#pos(@x), #0()) -> c_47() :37
-->_3 #eq^#(#neg(@x), #pos(@y)) -> c_46() :36
-->_2 #eq^#(#neg(@x), #pos(@y)) -> c_46() :36
-->_3 #eq^#(#neg(@x), #0()) -> c_44() :34
-->_2 #eq^#(#neg(@x), #0()) -> c_44() :34
-->_3 #eq^#(#0(), #s(@y)) -> c_43() :33
-->_2 #eq^#(#0(), #s(@y)) -> c_43() :33
-->_3 #eq^#(#0(), #pos(@y)) -> c_42() :32
-->_2 #eq^#(#0(), #pos(@y)) -> c_42() :32
-->_3 #eq^#(#0(), #neg(@y)) -> c_41() :31
-->_2 #eq^#(#0(), #neg(@y)) -> c_41() :31
-->_3 #eq^#(#0(), #0()) -> c_40() :30
-->_2 #eq^#(#0(), #0()) -> c_40() :30
-->_3 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :29
-->_2 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :29
-->_3 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :28
-->_2 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :28
-->_3 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :27
-->_2 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :27
-->_3 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :26
-->_2 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :26
-->_3 #eq^#(nil(), nil()) -> c_35() :25
-->_2 #eq^#(nil(), nil()) -> c_35() :25
-->_3 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :24
-->_2 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :24
-->_3 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :23
-->_2 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :23
-->_3 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :22
-->_2 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :22
-->_3 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :21
-->_2 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :21
30: #eq^#(#0(), #0()) -> c_40()
31: #eq^#(#0(), #neg(@y)) -> c_41()
32: #eq^#(#0(), #pos(@y)) -> c_42()
33: #eq^#(#0(), #s(@y)) -> c_43()
34: #eq^#(#neg(@x), #0()) -> c_44()
35: #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y)
-->_1 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :41
-->_1 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :39
-->_1 #eq^#(#s(@x), #0()) -> c_50() :40
-->_1 #eq^#(#pos(@x), #neg(@y)) -> c_48() :38
-->_1 #eq^#(#pos(@x), #0()) -> c_47() :37
-->_1 #eq^#(#neg(@x), #pos(@y)) -> c_46() :36
-->_1 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :35
-->_1 #eq^#(#neg(@x), #0()) -> c_44() :34
-->_1 #eq^#(#0(), #s(@y)) -> c_43() :33
-->_1 #eq^#(#0(), #pos(@y)) -> c_42() :32
-->_1 #eq^#(#0(), #neg(@y)) -> c_41() :31
-->_1 #eq^#(#0(), #0()) -> c_40() :30
-->_1 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :29
-->_1 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :28
-->_1 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :27
-->_1 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :26
-->_1 #eq^#(nil(), nil()) -> c_35() :25
-->_1 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :24
-->_1 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :23
-->_1 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :22
-->_1 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :21
36: #eq^#(#neg(@x), #pos(@y)) -> c_46()
37: #eq^#(#pos(@x), #0()) -> c_47()
38: #eq^#(#pos(@x), #neg(@y)) -> c_48()
39: #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y)
-->_1 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :41
-->_1 #eq^#(#s(@x), #0()) -> c_50() :40
-->_1 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :39
-->_1 #eq^#(#pos(@x), #neg(@y)) -> c_48() :38
-->_1 #eq^#(#pos(@x), #0()) -> c_47() :37
-->_1 #eq^#(#neg(@x), #pos(@y)) -> c_46() :36
-->_1 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :35
-->_1 #eq^#(#neg(@x), #0()) -> c_44() :34
-->_1 #eq^#(#0(), #s(@y)) -> c_43() :33
-->_1 #eq^#(#0(), #pos(@y)) -> c_42() :32
-->_1 #eq^#(#0(), #neg(@y)) -> c_41() :31
-->_1 #eq^#(#0(), #0()) -> c_40() :30
-->_1 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :29
-->_1 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :28
-->_1 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :27
-->_1 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :26
-->_1 #eq^#(nil(), nil()) -> c_35() :25
-->_1 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :24
-->_1 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :23
-->_1 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :22
-->_1 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :21
40: #eq^#(#s(@x), #0()) -> c_50()
41: #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y)
-->_1 #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y) :41
-->_1 #eq^#(#s(@x), #0()) -> c_50() :40
-->_1 #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y) :39
-->_1 #eq^#(#pos(@x), #neg(@y)) -> c_48() :38
-->_1 #eq^#(#pos(@x), #0()) -> c_47() :37
-->_1 #eq^#(#neg(@x), #pos(@y)) -> c_46() :36
-->_1 #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y) :35
-->_1 #eq^#(#neg(@x), #0()) -> c_44() :34
-->_1 #eq^#(#0(), #s(@y)) -> c_43() :33
-->_1 #eq^#(#0(), #pos(@y)) -> c_42() :32
-->_1 #eq^#(#0(), #neg(@y)) -> c_41() :31
-->_1 #eq^#(#0(), #0()) -> c_40() :30
-->_1 #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :29
-->_1 #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38() :28
-->_1 #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37() :27
-->_1 #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36() :26
-->_1 #eq^#(nil(), nil()) -> c_35() :25
-->_1 #eq^#(nil(), ::(@y_1, @y_2)) -> c_34() :24
-->_1 #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33() :23
-->_1 #eq^#(::(@x_1, @x_2), nil()) -> c_32() :22
-->_1 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2)) :21
42: #greater^#(@x, @y) ->
c_2(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y))
-->_2 #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y) :57
-->_2 #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y) :55
-->_2 #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x) :51
-->_2 #compare^#(#s(@x), #0()) -> c_62() :56
-->_2 #compare^#(#pos(@x), #neg(@y)) -> c_60() :54
-->_2 #compare^#(#pos(@x), #0()) -> c_59() :53
-->_2 #compare^#(#neg(@x), #pos(@y)) -> c_58() :52
-->_2 #compare^#(#neg(@x), #0()) -> c_56() :50
-->_2 #compare^#(#0(), #s(@y)) -> c_55() :49
-->_2 #compare^#(#0(), #pos(@y)) -> c_54() :48
-->_2 #compare^#(#0(), #neg(@y)) -> c_53() :47
-->_2 #compare^#(#0(), #0()) -> c_52() :46
-->_1 #ckgt^#(#LT()) -> c_66() :45
-->_1 #ckgt^#(#GT()) -> c_65() :44
-->_1 #ckgt^#(#EQ()) -> c_64() :43
43: #ckgt^#(#EQ()) -> c_64()
44: #ckgt^#(#GT()) -> c_65()
45: #ckgt^#(#LT()) -> c_66()
46: #compare^#(#0(), #0()) -> c_52()
47: #compare^#(#0(), #neg(@y)) -> c_53()
48: #compare^#(#0(), #pos(@y)) -> c_54()
49: #compare^#(#0(), #s(@y)) -> c_55()
50: #compare^#(#neg(@x), #0()) -> c_56()
51: #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x)
-->_1 #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y) :57
-->_1 #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y) :55
-->_1 #compare^#(#s(@x), #0()) -> c_62() :56
-->_1 #compare^#(#pos(@x), #neg(@y)) -> c_60() :54
-->_1 #compare^#(#pos(@x), #0()) -> c_59() :53
-->_1 #compare^#(#neg(@x), #pos(@y)) -> c_58() :52
-->_1 #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x) :51
-->_1 #compare^#(#neg(@x), #0()) -> c_56() :50
-->_1 #compare^#(#0(), #s(@y)) -> c_55() :49
-->_1 #compare^#(#0(), #pos(@y)) -> c_54() :48
-->_1 #compare^#(#0(), #neg(@y)) -> c_53() :47
-->_1 #compare^#(#0(), #0()) -> c_52() :46
52: #compare^#(#neg(@x), #pos(@y)) -> c_58()
53: #compare^#(#pos(@x), #0()) -> c_59()
54: #compare^#(#pos(@x), #neg(@y)) -> c_60()
55: #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y)
-->_1 #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y) :57
-->_1 #compare^#(#s(@x), #0()) -> c_62() :56
-->_1 #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y) :55
-->_1 #compare^#(#pos(@x), #neg(@y)) -> c_60() :54
-->_1 #compare^#(#pos(@x), #0()) -> c_59() :53
-->_1 #compare^#(#neg(@x), #pos(@y)) -> c_58() :52
-->_1 #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x) :51
-->_1 #compare^#(#neg(@x), #0()) -> c_56() :50
-->_1 #compare^#(#0(), #s(@y)) -> c_55() :49
-->_1 #compare^#(#0(), #pos(@y)) -> c_54() :48
-->_1 #compare^#(#0(), #neg(@y)) -> c_53() :47
-->_1 #compare^#(#0(), #0()) -> c_52() :46
56: #compare^#(#s(@x), #0()) -> c_62()
57: #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y)
-->_1 #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y) :57
-->_1 #compare^#(#s(@x), #0()) -> c_62() :56
-->_1 #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y) :55
-->_1 #compare^#(#pos(@x), #neg(@y)) -> c_60() :54
-->_1 #compare^#(#pos(@x), #0()) -> c_59() :53
-->_1 #compare^#(#neg(@x), #pos(@y)) -> c_58() :52
-->_1 #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x) :51
-->_1 #compare^#(#neg(@x), #0()) -> c_56() :50
-->_1 #compare^#(#0(), #s(@y)) -> c_55() :49
-->_1 #compare^#(#0(), #pos(@y)) -> c_54() :48
-->_1 #compare^#(#0(), #neg(@y)) -> c_53() :47
-->_1 #compare^#(#0(), #0()) -> c_52() :46
58: append#1^#(nil(), @ys) -> c_5()
59: insert#2^#(nil(), @keyX, @valX, @x) -> c_9()
60: insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) -> c_12()
61: quicksort#1^#(nil()) -> c_15()
62: splitqs#1^#(nil(), @pivot) -> c_27()
63: sortAll#1^#(nil()) -> c_20()
64: split#1^#(nil()) -> c_24()
65: splitqs#3^#(#false(), @ls, @rs, @x) -> c_29()
66: splitqs#3^#(#true(), @ls, @rs, @x) -> c_30()
67: #and^#(#false(), #false()) -> c_67()
68: #and^#(#false(), #true()) -> c_68()
69: #and^#(#true(), #false()) -> c_69()
70: #and^#(#true(), #true()) -> c_70()
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {19} and add Pre({19}) = {12} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX))
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_14(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_17(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_21(quicksort^#(@vals), sortAll^#(@xs))
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_23(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> c_25(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ #equal^#(@x, @y) -> #eq^#(@x, @y)
, #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, #eq^#(::(@x_1, @x_2), nil()) -> c_32()
, #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33()
, #eq^#(nil(), ::(@y_1, @y_2)) -> c_34()
, #eq^#(nil(), nil()) -> c_35()
, #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36()
, #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37()
, #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38()
, #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, #eq^#(#0(), #0()) -> c_40()
, #eq^#(#0(), #neg(@y)) -> c_41()
, #eq^#(#0(), #pos(@y)) -> c_42()
, #eq^#(#0(), #s(@y)) -> c_43()
, #eq^#(#neg(@x), #0()) -> c_44()
, #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y)
, #eq^#(#neg(@x), #pos(@y)) -> c_46()
, #eq^#(#pos(@x), #0()) -> c_47()
, #eq^#(#pos(@x), #neg(@y)) -> c_48()
, #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y)
, #eq^#(#s(@x), #0()) -> c_50()
, #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y)
, #greater^#(@x, @y) ->
c_2(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y))
, #ckgt^#(#EQ()) -> c_64()
, #ckgt^#(#GT()) -> c_65()
, #ckgt^#(#LT()) -> c_66()
, #compare^#(#0(), #0()) -> c_52()
, #compare^#(#0(), #neg(@y)) -> c_53()
, #compare^#(#0(), #pos(@y)) -> c_54()
, #compare^#(#0(), #s(@y)) -> c_55()
, #compare^#(#neg(@x), #0()) -> c_56()
, #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x)
, #compare^#(#neg(@x), #pos(@y)) -> c_58()
, #compare^#(#pos(@x), #0()) -> c_59()
, #compare^#(#pos(@x), #neg(@y)) -> c_60()
, #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y)
, #compare^#(#s(@x), #0()) -> c_62()
, #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y)
, append#1^#(nil(), @ys) -> c_5()
, insert#2^#(nil(), @keyX, @valX, @x) -> c_9()
, insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) -> c_12()
, quicksort#1^#(nil()) -> c_15()
, splitqs#1^#(nil(), @pivot) -> c_27()
, sortAll#1^#(nil()) -> c_20()
, split#1^#(nil()) -> c_24()
, splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
#greater^#(@x, @pivot))
, splitqs#3^#(#false(), @ls, @rs, @x) -> c_29()
, splitqs#3^#(#true(), @ls, @rs, @x) -> c_30()
, #and^#(#false(), #false()) -> c_67()
, #and^#(#false(), #true()) -> c_68()
, #and^#(#true(), #false()) -> c_69()
, #and^#(#true(), #true()) -> c_70() }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the the dependency graph
->1:{18}
|
|->4:{13,15,14}
| |
| |->6:{8,10,9}
| | |
| | |->52:{1,2}
| | | |
| | | `->53:{57} Weak SCC
| | |
| | |->8:{11,12}
| | | |
| | | |->9:{61} Weak SCC
| | | |
| | | `->10:{64} Weak SCC
| | | |
| | | |->11:{41} Weak SCC
| | | | |
| | | | |->12:{42} Weak SCC
| | | | |
| | | | |->13:{43} Weak SCC
| | | | |
| | | | |->14:{44} Weak SCC
| | | | |
| | | | |->16:{45} Weak SCC
| | | | |
| | | | |->17:{46} Weak SCC
| | | | |
| | | | |->18:{47} Weak SCC
| | | | |
| | | | |->19:{48} Weak SCC
| | | | |
| | | | |->20:{49} Weak SCC
| | | | |
| | | | |->21:{51} Weak SCC
| | | | |
| | | | |->22:{52} Weak SCC
| | | | |
| | | | |->23:{53} Weak SCC
| | | | |
| | | | |->24:{55} Weak SCC
| | | | |
| | | | `->15:{56,54,50} Weak SCC
| | | | |
| | | | |->16:{45} Weak SCC
| | | | |
| | | | |->17:{46} Weak SCC
| | | | |
| | | | |->18:{47} Weak SCC
| | | | |
| | | | |->19:{48} Weak SCC
| | | | |
| | | | |->20:{49} Weak SCC
| | | | |
| | | | |->21:{51} Weak SCC
| | | | |
| | | | |->22:{52} Weak SCC
| | | | |
| | | | |->23:{53} Weak SCC
| | | | |
| | | | `->24:{55} Weak SCC
| | | |
| | | |->25:{65} Weak SCC
| | | |
| | | `->26:{66} Weak SCC
| | |
| | `->7:{60} Weak SCC
| |
| `->5:{62} Weak SCC
|
`->2:{16,17}
|
|->27:{3,7,6,5,4}
| |
| |->30:{19} Weak SCC
| | |
| | |->32:{21} Weak SCC
| | |
| | |->33:{22} Weak SCC
| | |
| | |->34:{23} Weak SCC
| | |
| | |->35:{24} Weak SCC
| | |
| | |->36:{25} Weak SCC
| | |
| | |->37:{26} Weak SCC
| | |
| | |->38:{27} Weak SCC
| | |
| | |->43:{29} Weak SCC
| | |
| | |->44:{30} Weak SCC
| | |
| | |->45:{31} Weak SCC
| | |
| | |->46:{32} Weak SCC
| | |
| | |->47:{33} Weak SCC
| | |
| | |->48:{35} Weak SCC
| | |
| | |->49:{36} Weak SCC
| | |
| | |->50:{37} Weak SCC
| | |
| | |->51:{39} Weak SCC
| | |
| | `->31:{40,38,34,28,20} Weak SCC
| | |
| | |->32:{21} Weak SCC
| | |
| | |->33:{22} Weak SCC
| | |
| | |->34:{23} Weak SCC
| | |
| | |->35:{24} Weak SCC
| | |
| | |->36:{25} Weak SCC
| | |
| | |->37:{26} Weak SCC
| | |
| | |->38:{27} Weak SCC
| | |
| | |->43:{29} Weak SCC
| | |
| | |->44:{30} Weak SCC
| | |
| | |->45:{31} Weak SCC
| | |
| | |->46:{32} Weak SCC
| | |
| | |->47:{33} Weak SCC
| | |
| | |->48:{35} Weak SCC
| | |
| | |->49:{36} Weak SCC
| | |
| | |->50:{37} Weak SCC
| | |
| | |->51:{39} Weak SCC
| | |
| | |->39:{67} Weak SCC
| | |
| | |->40:{68} Weak SCC
| | |
| | |->41:{69} Weak SCC
| | |
| | `->42:{70} Weak SCC
| |
| |->28:{58} Weak SCC
| |
| `->29:{59} Weak SCC
|
`->3:{63} Weak SCC
Here dependency-pairs are as follows:
Strict DPs:
{ 1: append^#(@l, @ys) -> append#1^#(@l, @ys)
, 2: append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, 3: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, 4: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, 5: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, 6: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX))
, 7: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, 8: quicksort^#(@l) -> quicksort#1^#(@l)
, 9: quicksort#1^#(::(@z, @zs)) ->
c_14(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, 10: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_17(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, 11: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, 12: splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs))
, 13: sortAll^#(@l) -> sortAll#1^#(@l)
, 14: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, 15: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_21(quicksort^#(@vals), sortAll^#(@xs))
, 16: split^#(@l) -> split#1^#(@l)
, 17: split#1^#(::(@x, @xs)) ->
c_23(insert^#(@x, split(@xs)), split^#(@xs))
, 18: splitAndSort^#(@l) ->
c_25(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ 19: #equal^#(@x, @y) -> #eq^#(@x, @y)
, 20: #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, 21: #eq^#(::(@x_1, @x_2), nil()) -> c_32()
, 22: #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33()
, 23: #eq^#(nil(), ::(@y_1, @y_2)) -> c_34()
, 24: #eq^#(nil(), nil()) -> c_35()
, 25: #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36()
, 26: #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37()
, 27: #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38()
, 28: #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, 29: #eq^#(#0(), #0()) -> c_40()
, 30: #eq^#(#0(), #neg(@y)) -> c_41()
, 31: #eq^#(#0(), #pos(@y)) -> c_42()
, 32: #eq^#(#0(), #s(@y)) -> c_43()
, 33: #eq^#(#neg(@x), #0()) -> c_44()
, 34: #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y)
, 35: #eq^#(#neg(@x), #pos(@y)) -> c_46()
, 36: #eq^#(#pos(@x), #0()) -> c_47()
, 37: #eq^#(#pos(@x), #neg(@y)) -> c_48()
, 38: #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y)
, 39: #eq^#(#s(@x), #0()) -> c_50()
, 40: #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y)
, 41: #greater^#(@x, @y) ->
c_2(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y))
, 42: #ckgt^#(#EQ()) -> c_64()
, 43: #ckgt^#(#GT()) -> c_65()
, 44: #ckgt^#(#LT()) -> c_66()
, 45: #compare^#(#0(), #0()) -> c_52()
, 46: #compare^#(#0(), #neg(@y)) -> c_53()
, 47: #compare^#(#0(), #pos(@y)) -> c_54()
, 48: #compare^#(#0(), #s(@y)) -> c_55()
, 49: #compare^#(#neg(@x), #0()) -> c_56()
, 50: #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x)
, 51: #compare^#(#neg(@x), #pos(@y)) -> c_58()
, 52: #compare^#(#pos(@x), #0()) -> c_59()
, 53: #compare^#(#pos(@x), #neg(@y)) -> c_60()
, 54: #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y)
, 55: #compare^#(#s(@x), #0()) -> c_62()
, 56: #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y)
, 57: append#1^#(nil(), @ys) -> c_5()
, 58: insert#2^#(nil(), @keyX, @valX, @x) -> c_9()
, 59: insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) -> c_12()
, 60: quicksort#1^#(nil()) -> c_15()
, 61: splitqs#1^#(nil(), @pivot) -> c_27()
, 62: sortAll#1^#(nil()) -> c_20()
, 63: split#1^#(nil()) -> c_24()
, 64: splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
#greater^#(@x, @pivot))
, 65: splitqs#3^#(#false(), @ls, @rs, @x) -> c_29()
, 66: splitqs#3^#(#true(), @ls, @rs, @x) -> c_30()
, 67: #and^#(#false(), #false()) -> c_67()
, 68: #and^#(#false(), #true()) -> c_68()
, 69: #and^#(#true(), #false()) -> c_69()
, 70: #and^#(#true(), #true()) -> c_70() }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 63: split#1^#(nil()) -> c_24()
, 62: sortAll#1^#(nil()) -> c_20()
, 60: quicksort#1^#(nil()) -> c_15()
, 61: splitqs#1^#(nil(), @pivot) -> c_27()
, 64: splitqs#2^#(tuple#2(@ls, @rs), @pivot, @x) ->
c_28(splitqs#3^#(#greater(@x, @pivot), @ls, @rs, @x),
#greater^#(@x, @pivot))
, 41: #greater^#(@x, @y) ->
c_2(#ckgt^#(#compare(@x, @y)), #compare^#(@x, @y))
, 42: #ckgt^#(#EQ()) -> c_64()
, 43: #ckgt^#(#GT()) -> c_65()
, 44: #ckgt^#(#LT()) -> c_66()
, 56: #compare^#(#s(@x), #s(@y)) -> #compare^#(@x, @y)
, 54: #compare^#(#pos(@x), #pos(@y)) -> #compare^#(@x, @y)
, 50: #compare^#(#neg(@x), #neg(@y)) -> #compare^#(@y, @x)
, 45: #compare^#(#0(), #0()) -> c_52()
, 46: #compare^#(#0(), #neg(@y)) -> c_53()
, 47: #compare^#(#0(), #pos(@y)) -> c_54()
, 48: #compare^#(#0(), #s(@y)) -> c_55()
, 49: #compare^#(#neg(@x), #0()) -> c_56()
, 51: #compare^#(#neg(@x), #pos(@y)) -> c_58()
, 52: #compare^#(#pos(@x), #0()) -> c_59()
, 53: #compare^#(#pos(@x), #neg(@y)) -> c_60()
, 55: #compare^#(#s(@x), #0()) -> c_62()
, 65: splitqs#3^#(#false(), @ls, @rs, @x) -> c_29()
, 66: splitqs#3^#(#true(), @ls, @rs, @x) -> c_30()
, 58: insert#2^#(nil(), @keyX, @valX, @x) -> c_9()
, 59: insert#4^#(#true(), @key1, @ls, @valX, @vals1, @x) -> c_12()
, 19: #equal^#(@x, @y) -> #eq^#(@x, @y)
, 40: #eq^#(#s(@x), #s(@y)) -> #eq^#(@x, @y)
, 38: #eq^#(#pos(@x), #pos(@y)) -> #eq^#(@x, @y)
, 34: #eq^#(#neg(@x), #neg(@y)) -> #eq^#(@x, @y)
, 28: #eq^#(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
c_39(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, 20: #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
c_31(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
#eq^#(@x_1, @y_1),
#eq^#(@x_2, @y_2))
, 21: #eq^#(::(@x_1, @x_2), nil()) -> c_32()
, 22: #eq^#(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> c_33()
, 23: #eq^#(nil(), ::(@y_1, @y_2)) -> c_34()
, 24: #eq^#(nil(), nil()) -> c_35()
, 25: #eq^#(nil(), tuple#2(@y_1, @y_2)) -> c_36()
, 26: #eq^#(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> c_37()
, 27: #eq^#(tuple#2(@x_1, @x_2), nil()) -> c_38()
, 67: #and^#(#false(), #false()) -> c_67()
, 68: #and^#(#false(), #true()) -> c_68()
, 69: #and^#(#true(), #false()) -> c_69()
, 70: #and^#(#true(), #true()) -> c_70()
, 29: #eq^#(#0(), #0()) -> c_40()
, 30: #eq^#(#0(), #neg(@y)) -> c_41()
, 31: #eq^#(#0(), #pos(@y)) -> c_42()
, 32: #eq^#(#0(), #s(@y)) -> c_43()
, 33: #eq^#(#neg(@x), #0()) -> c_44()
, 35: #eq^#(#neg(@x), #pos(@y)) -> c_46()
, 36: #eq^#(#pos(@x), #0()) -> c_47()
, 37: #eq^#(#pos(@x), #neg(@y)) -> c_48()
, 39: #eq^#(#s(@x), #0()) -> c_50()
, 57: append#1^#(nil(), @ys) -> c_5() }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX))
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_14(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_17(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_21(quicksort^#(@vals), sortAll^#(@xs))
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_23(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> c_25(sortAll^#(split(@l)), split^#(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the following dependency-graph
1: append^#(@l, @ys) -> append#1^#(@l, @ys)
-->_1 append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys) :2
2: append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
3: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
-->_1 insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x) :4
4: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
-->_1 insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x) :5
5: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
-->_1 insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX)) :6
6: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX))
-->_1 insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) :7
7: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :3
8: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_14(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :9
9: quicksort#1^#(::(@z, @zs)) ->
c_14(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :11
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_17(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :10
10: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_17(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :8
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :8
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
11: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
-->_1 splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs)) :12
12: splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs))
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :11
13: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :14
14: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_21(quicksort^#(@vals), sortAll^#(@xs)) :15
15: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_21(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :13
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :8
16: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) ->
c_23(insert^#(@x, split(@xs)), split^#(@xs)) :17
17: split#1^#(::(@x, @xs)) ->
c_23(insert^#(@x, split(@xs)), split^#(@xs))
-->_2 split^#(@l) -> split#1^#(@l) :16
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :3
18: splitAndSort^#(@l) -> c_25(sortAll^#(split(@l)), split^#(@l))
-->_2 split^#(@l) -> split#1^#(@l) :16
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :13
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
c_10(insert#4^#(#equal(@key1, @keyX),
@key1,
@ls,
@valX,
@vals1,
@x),
#equal^#(@key1, @keyX))
, splitqs#1^#(::(@x, @xs), @pivot) ->
c_26(splitqs#2^#(splitqs(@pivot, @xs), @pivot, @x),
splitqs^#(@pivot, @xs)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We employ 'linear path analysis' using the following approximated
dependency graph:
->1:{18} [ ? ]
|
|->3:{13,15,14} [ ? ]
| |
| `->4:{8,10,9} [ ? ]
| |
| |->7:{1,2} [ MAYBE ]
| |
| `->5:{11,12} [ YES(O(1),O(n^3)) ]
|
`->2:{16,17} [ ? ]
|
`->6:{3,7,6,5,4} [ YES(O(1),O(n^2)) ]
Here dependency-pairs are as follows:
Strict DPs:
{ 1: append^#(@l, @ys) -> append#1^#(@l, @ys)
, 2: append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, 3: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, 4: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, 5: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, 6: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, 7: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, 8: quicksort^#(@l) -> quicksort#1^#(@l)
, 9: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, 10: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, 11: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, 12: splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, 13: sortAll^#(@l) -> sortAll#1^#(@l)
, 14: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, 15: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, 16: split^#(@l) -> split#1^#(@l)
, 17: split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
, 18: splitAndSort^#(@l) ->
c_5(sortAll^#(split(@l)), split^#(@l)) }
* Path 1:{18}->3:{13,15,14}->4:{8,10,9}->7:{1,2}: MAYBE
-----------------------------------------------------
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append^#(@l, @ys) -> append#1^#(@l, @ys)
-->_1 append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys) :2
2: append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
3: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :4
4: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :5
5: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :3
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :3
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
6: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :7
7: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :8
8: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :6
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :3
9: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :6
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs: { append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append^#(@l, @ys) -> append#1^#(@l, @ys)
-->_1 append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys) :9
2: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :3
3: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :4
4: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :2
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :2
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
5: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :6
6: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :7
7: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :5
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :2
8: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :5
9: append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {4} and add Pre({4}) = {3} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append^#(@l, @ys) -> append#1^#(@l, @ys)
-->_1 append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys) :8
2: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :3
3: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :9
4: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :5
5: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :6
6: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :4
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :2
7: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :4
8: append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
9: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :2
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :2
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append^#(@l, @ys) -> append#1^#(@l, @ys)
-->_1 append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys) :7
2: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :8
3: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :4
4: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :5
5: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :3
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :2
6: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :3
7: append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
8: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :9
9: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :2
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :2
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {5} and add Pre({5}) = {4} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append^#(@l, @ys) -> append#1^#(@l, @ys)
-->_1 append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys) :6
2: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :7
3: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :4
4: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :9
5: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :3
6: append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
7: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :8
8: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :2
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :2
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
9: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :3
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :2
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {4} and add Pre({4}) = {3} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l)
, sortAll^#(@l) -> sortAll#1^#(@l)
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the (estimated) dependency graph
1: append^#(@l, @ys) -> append#1^#(@l, @ys)
-->_1 append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys) :5
2: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :6
3: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :8
4: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :3
5: append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
6: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :7
7: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :2
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :2
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
8: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :9
9: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :3
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :2
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {4} and add Pre({4}) = {} to the strict component.
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l)
, sortAll^#(@l) -> sortAll#1^#(@l) }
Weak DPs:
{ append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We consider the following dependency-graph
1: append^#(@l, @ys) -> append#1^#(@l, @ys)
-->_1 append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys) :4
2: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :5
3: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :7
4: append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
5: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :6
6: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :2
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :2
-->_1 append^#(@l, @ys) -> append#1^#(@l, @ys) :1
7: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :8
8: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :3
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :2
9: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :3
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l)
, sortAll^#(@l) -> sortAll#1^#(@l) }
Weak DPs:
{ append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_2(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
We are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l)
, sortAll^#(@l) -> sortAll#1^#(@l) }
Weak DPs:
{ append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_2(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
None of the processors succeeded.
Details of failed attempt(s):
-----------------------------
1) 'empty' failed due to the following reason:
Empty strict component of the problem is NOT empty.
2) 'With Problem ...' failed due to the following reason:
We measure the number of applications of following selected rules
relative to the remaining rules.
Selected Rules (A):
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) }
Remaining Rules (B):
{ sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_2(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
The length of a single A-subderivation is expressed by the
following problem.
Problem (A):
------------
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l) }
Weak DPs:
{ append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
The number of B-applications is expressed by the following problem.
Problem (B):
------------
Strict DPs:
{ sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_2(quicksort^#(@vals), sortAll^#(@xs)) }
Weak DPs:
{ sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
TcT answers on problem (B) 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:
{ sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_2(quicksort^#(@vals), sortAll^#(@xs)) }
Weak DPs:
{ sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the following dependency-graph
1: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :3
2: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_2(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :1
3: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_2(quicksort^#(@vals), sortAll^#(@xs)) :2
4: splitAndSort^#(@l) -> sortAll^#(split(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_2(quicksort^#(@vals), sortAll^#(@xs)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs) }
Weak DPs:
{ sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs) }
Weak DPs:
{ sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
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: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, 4: splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Trs:
{ insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split#1(nil()) -> nil() }
Sub-proof:
----------
The following argument positions are usable:
Uargs(#equal) = {}, Uargs(#eq) = {}, Uargs(#greater) = {},
Uargs(#compare) = {}, Uargs(#ckgt) = {}, Uargs(append) = {},
Uargs(append#1) = {}, Uargs(::) = {}, Uargs(insert) = {},
Uargs(insert#1) = {}, Uargs(tuple#2) = {}, Uargs(insert#2) = {},
Uargs(insert#3) = {}, Uargs(insert#4) = {}, Uargs(quicksort) = {},
Uargs(quicksort#1) = {}, Uargs(splitqs) = {},
Uargs(quicksort#2) = {}, Uargs(split) = {}, Uargs(split#1) = {},
Uargs(splitqs#1) = {}, Uargs(splitqs#2) = {},
Uargs(splitqs#3) = {}, Uargs(#and) = {}, Uargs(#neg) = {},
Uargs(#pos) = {}, Uargs(#s) = {}, Uargs(#equal^#) = {},
Uargs(#eq^#) = {}, Uargs(#greater^#) = {}, Uargs(#ckgt^#) = {},
Uargs(#compare^#) = {}, Uargs(append^#) = {},
Uargs(append#1^#) = {}, Uargs(insert^#) = {},
Uargs(insert#1^#) = {}, Uargs(insert#2^#) = {},
Uargs(insert#3^#) = {}, Uargs(insert#4^#) = {},
Uargs(quicksort^#) = {}, Uargs(quicksort#1^#) = {},
Uargs(quicksort#2^#) = {}, Uargs(splitqs^#) = {},
Uargs(splitqs#1^#) = {}, Uargs(sortAll^#) = {},
Uargs(sortAll#1^#) = {}, Uargs(sortAll#2^#) = {},
Uargs(split^#) = {}, Uargs(split#1^#) = {},
Uargs(splitAndSort^#) = {}, Uargs(splitqs#2^#) = {},
Uargs(splitqs#3^#) = {}, Uargs(#and^#) = {}, Uargs(c_2) = {}
TcT has computed following constructor-based matrix interpretation
satisfying not(EDA).
[#equal](x1, x2) = [1]
[#eq](x1, x2) = [1]
[#greater](x1, x2) = [0]
[#compare](x1, x2) = [0]
[#ckgt](x1) = [0]
[append](x1, x2) = [0]
[append#1](x1, x2) = [0]
[::](x1, x2) = [1] x1 + [1] x2 + [1]
[nil] = [1]
[insert](x1, x2) = [1] x2 + [2]
[insert#1](x1, x2, x3) = [1] x2 + [2]
[tuple#2](x1, x2) = [0]
[insert#2](x1, x2, x3, x4) = [1] x1 + [2]
[insert#3](x1, x2, x3, x4, x5) = [1] x3 + [3]
[insert#4](x1, x2, x3, x4, x5, x6) = [2] x1 + [1] x3 + [1]
[#false] = [1]
[#true] = [1]
[quicksort](x1) = [0]
[quicksort#1](x1) = [0]
[splitqs](x1, x2) = [0]
[quicksort#2](x1, x2) = [0]
[split](x1) = [2] x1 + [1]
[split#1](x1) = [2] x1 + [1]
[splitqs#1](x1, x2) = [0]
[splitqs#2](x1, x2, x3) = [0]
[splitqs#3](x1, x2, x3, x4) = [0]
[#and](x1, x2) = [1] x1 + [0]
[#EQ] = [0]
[#GT] = [0]
[#LT] = [0]
[#0] = [0]
[#neg](x1) = [1] x1 + [0]
[#pos](x1) = [1] x1 + [0]
[#s](x1) = [1] x1 + [0]
[#equal^#](x1, x2) = [0]
[#eq^#](x1, x2) = [0]
[#greater^#](x1, x2) = [0]
[#ckgt^#](x1) = [0]
[#compare^#](x1, x2) = [0]
[append^#](x1, x2) = [0]
[append#1^#](x1, x2) = [0]
[insert^#](x1, x2) = [0]
[insert#1^#](x1, x2, x3) = [0]
[insert#2^#](x1, x2, x3, x4) = [0]
[insert#3^#](x1, x2, x3, x4, x5) = [0]
[insert#4^#](x1, x2, x3, x4, x5, x6) = [0]
[quicksort^#](x1) = [0]
[quicksort#1^#](x1) = [0]
[quicksort#2^#](x1, x2) = [0]
[splitqs^#](x1, x2) = [0]
[splitqs#1^#](x1, x2) = [0]
[sortAll^#](x1) = [1] x1 + [1]
[sortAll#1^#](x1) = [1] x1 + [1]
[sortAll#2^#](x1, x2) = [1] x2 + [2]
[split^#](x1) = [0]
[split#1^#](x1) = [0]
[splitAndSort^#](x1) = [3] x1 + [3]
[splitqs#2^#](x1, x2, x3) = [0]
[splitqs#3^#](x1, x2, x3, x4) = [0]
[#and^#](x1, x2) = [0]
[c_2](x1, x2) = [0]
[c] = [0]
This order satisfies following ordering constraints
[#equal(@x, @y)] = [1]
>= [1]
= [#eq(@x, @y)]
[#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [1]
>= [1]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(::(@x_1, @x_2), nil())] = [1]
>= [1]
= [#false()]
[#eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2))] = [1]
>= [1]
= [#false()]
[#eq(nil(), ::(@y_1, @y_2))] = [1]
>= [1]
= [#false()]
[#eq(nil(), nil())] = [1]
>= [1]
= [#true()]
[#eq(nil(), tuple#2(@y_1, @y_2))] = [1]
>= [1]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2))] = [1]
>= [1]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), nil())] = [1]
>= [1]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2))] = [1]
>= [1]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(#0(), #0())] = [1]
>= [1]
= [#true()]
[#eq(#0(), #neg(@y))] = [1]
>= [1]
= [#false()]
[#eq(#0(), #pos(@y))] = [1]
>= [1]
= [#false()]
[#eq(#0(), #s(@y))] = [1]
>= [1]
= [#false()]
[#eq(#neg(@x), #0())] = [1]
>= [1]
= [#false()]
[#eq(#neg(@x), #neg(@y))] = [1]
>= [1]
= [#eq(@x, @y)]
[#eq(#neg(@x), #pos(@y))] = [1]
>= [1]
= [#false()]
[#eq(#pos(@x), #0())] = [1]
>= [1]
= [#false()]
[#eq(#pos(@x), #neg(@y))] = [1]
>= [1]
= [#false()]
[#eq(#pos(@x), #pos(@y))] = [1]
>= [1]
= [#eq(@x, @y)]
[#eq(#s(@x), #0())] = [1]
>= [1]
= [#false()]
[#eq(#s(@x), #s(@y))] = [1]
>= [1]
= [#eq(@x, @y)]
[insert(@x, @l)] = [1] @l + [2]
>= [1] @l + [2]
= [insert#1(@x, @l, @x)]
[insert#1(tuple#2(@valX, @keyX), @l, @x)] = [1] @l + [2]
>= [1] @l + [2]
= [insert#2(@l, @keyX, @valX, @x)]
[insert#2(::(@l1, @ls), @keyX, @valX, @x)] = [1] @l1 + [1] @ls + [3]
>= [1] @ls + [3]
= [insert#3(@l1, @keyX, @ls, @valX, @x)]
[insert#2(nil(), @keyX, @valX, @x)] = [3]
> [2]
= [::(tuple#2(::(@valX, nil()), @keyX), nil())]
[insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x)] = [1] @ls + [3]
>= [1] @ls + [3]
= [insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)]
[insert#4(#false(), @key1, @ls, @valX, @vals1, @x)] = [1] @ls + [3]
>= [1] @ls + [3]
= [::(tuple#2(@vals1, @key1), insert(@x, @ls))]
[insert#4(#true(), @key1, @ls, @valX, @vals1, @x)] = [1] @ls + [3]
> [1] @ls + [1]
= [::(tuple#2(::(@valX, @vals1), @key1), @ls)]
[split(@l)] = [2] @l + [1]
>= [2] @l + [1]
= [split#1(@l)]
[split#1(::(@x, @xs))] = [2] @x + [2] @xs + [3]
>= [2] @xs + [3]
= [insert(@x, split(@xs))]
[split#1(nil())] = [3]
> [1]
= [nil()]
[#and(#false(), #false())] = [1]
>= [1]
= [#false()]
[#and(#false(), #true())] = [1]
>= [1]
= [#false()]
[#and(#true(), #false())] = [1]
>= [1]
= [#false()]
[#and(#true(), #true())] = [1]
>= [1]
= [#true()]
[sortAll^#(@l)] = [1] @l + [1]
>= [1] @l + [1]
= [sortAll#1^#(@l)]
[sortAll#1^#(::(@x, @xs))] = [1] @x + [1] @xs + [2]
>= [1] @xs + [2]
= [sortAll#2^#(@x, @xs)]
[sortAll#2^#(tuple#2(@vals, @key), @xs)] = [1] @xs + [2]
> [1] @xs + [1]
= [sortAll^#(@xs)]
[splitAndSort^#(@l)] = [3] @l + [3]
> [2] @l + [2]
= [sortAll^#(split(@l))]
Processor 'matrix interpretation of dimension 1' induces the
complexity certificate YES(?,O(n^1)) on application of rules {2,4}.
Here rules are labeled according to the (estimated) dependency
graph
1: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :3
2: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :1
3: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs) :2
4: splitAndSort^#(@l) -> sortAll^#(split(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :1
- The rules {2,4} have known complexity. These cover all
predecessors of {1}, their complexity is equally bounded.
- The rules {1,2,4} have known complexity. These cover all
predecessors of {3}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules
{1,2,3,4} is given by YES(?,O(n^1)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{4} Weak SCC
|
`->2:{1,3,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: sortAll^#(@l) -> sortAll#1^#(@l)
, 2: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, 3: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, 4: splitAndSort^#(@l) -> sortAll^#(split(@l)) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 4: splitAndSort^#(@l) -> sortAll^#(split(@l))
, 1: sortAll^#(@l) -> sortAll#1^#(@l)
, 3: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, 2: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) }
We apply the transformation 'usablerules' on the sub-problem:
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
No rule is usable.
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
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 are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs:
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l) }
Weak DPs:
{ append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
We measure the number of applications of following selected rules
relative to the remaining rules.
Selected Rules (A):
{ append^#(@l, @ys) -> append#1^#(@l, @ys)
, append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys) }
Remaining Rules (B):
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
The length of a single A-subderivation is expressed by the
following problem.
Problem (A):
------------
Strict DPs: { append^#(@l, @ys) -> append#1^#(@l, @ys) }
Weak DPs:
{ append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
append^#(quicksort(@xs), ::(@z, quicksort(@ys)))
, quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs)
, quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
The number of B-applications is expressed by the following problem.
Problem (B):
------------
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
TcT answers on problem (B) 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:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the following dependency-graph
1: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z) :3
2: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :1
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :1
3: quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z)
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :2
4: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :5
5: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs) :7
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
quicksort^#(@vals) :6
6: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
7: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :4
8: splitAndSort^#(@l) -> sortAll^#(split(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :4
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys)) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys)) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
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: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys))
, 6: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, 8: splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Trs:
{ #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#s(@x), #0()) -> #false()
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split#1(nil()) -> nil()
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil()) }
Sub-proof:
----------
The following argument positions are usable:
Uargs(#equal) = {}, Uargs(#eq) = {}, Uargs(#greater) = {},
Uargs(#compare) = {}, Uargs(#ckgt) = {}, Uargs(append) = {},
Uargs(append#1) = {}, Uargs(::) = {}, Uargs(insert) = {},
Uargs(insert#1) = {}, Uargs(tuple#2) = {}, Uargs(insert#2) = {},
Uargs(insert#3) = {}, Uargs(insert#4) = {}, Uargs(quicksort) = {},
Uargs(quicksort#1) = {}, Uargs(splitqs) = {},
Uargs(quicksort#2) = {}, Uargs(split) = {}, Uargs(split#1) = {},
Uargs(splitqs#1) = {}, Uargs(splitqs#2) = {},
Uargs(splitqs#3) = {}, Uargs(#and) = {}, Uargs(#neg) = {},
Uargs(#pos) = {}, Uargs(#s) = {}, Uargs(#equal^#) = {},
Uargs(#eq^#) = {}, Uargs(#greater^#) = {}, Uargs(#ckgt^#) = {},
Uargs(#compare^#) = {}, Uargs(append^#) = {},
Uargs(append#1^#) = {}, Uargs(insert^#) = {},
Uargs(insert#1^#) = {}, Uargs(insert#2^#) = {},
Uargs(insert#3^#) = {}, Uargs(insert#4^#) = {},
Uargs(quicksort^#) = {}, Uargs(quicksort#1^#) = {},
Uargs(quicksort#2^#) = {}, Uargs(splitqs^#) = {},
Uargs(splitqs#1^#) = {}, Uargs(sortAll^#) = {},
Uargs(sortAll#1^#) = {}, Uargs(sortAll#2^#) = {},
Uargs(split^#) = {}, Uargs(split#1^#) = {},
Uargs(splitAndSort^#) = {}, Uargs(splitqs#2^#) = {},
Uargs(splitqs#3^#) = {}, Uargs(#and^#) = {}, Uargs(c_1) = {},
Uargs(c_1) = {1, 2}
TcT has computed following constructor-based matrix interpretation
satisfying not(EDA) and not(IDA(1)).
[#equal](x1, x2) = [0 0] x1 + [3 0] x2 + [3]
[1 3] [2 0] [3]
[#eq](x1, x2) = [3]
[3]
[#greater](x1, x2) = [0 0] x1 + [0 0] x2 + [0]
[0 2] [0 2] [1]
[#compare](x1, x2) = [0 1] x1 + [0 1] x2 + [1]
[0 1] [0 1] [0]
[#ckgt](x1) = [0 0] x1 + [0]
[1 1] [0]
[append](x1, x2) = [0]
[0]
[append#1](x1, x2) = [0]
[0]
[::](x1, x2) = [0 2] x1 + [1 0] x2 + [0]
[0 0] [0 1] [1]
[nil] = [3]
[0]
[insert](x1, x2) = [1 0] x2 + [3]
[0 1] [1]
[insert#1](x1, x2, x3) = [1 0] x2 + [3]
[0 1] [1]
[tuple#2](x1, x2) = [0 2] x1 + [0 2] x2 + [1]
[0 1] [0 0] [0]
[insert#2](x1, x2, x3, x4) = [1 0] x1 + [3]
[0 1] [1]
[insert#3](x1, x2, x3, x4, x5) = [0 2] x1 + [1 0] x3 + [3]
[0 0] [0 1] [2]
[insert#4](x1, x2, x3, x4, x5, x6) = [1 0] x3 + [0 2] x5 + [3]
[0 1] [0 0] [2]
[#false] = [0]
[3]
[#true] = [0]
[1]
[quicksort](x1) = [0]
[0]
[quicksort#1](x1) = [0]
[0]
[splitqs](x1, x2) = [0 0] x1 + [0 2] x2 + [2]
[0 2] [1 2] [1]
[quicksort#2](x1, x2) = [0]
[0]
[split](x1) = [1 3] x1 + [1]
[1 1] [3]
[split#1](x1) = [1 3] x1 + [1]
[1 1] [3]
[splitqs#1](x1, x2) = [0 2] x1 + [0 0] x2 + [2]
[1 2] [0 2] [0]
[splitqs#2](x1, x2, x3) = [1 0] x1 + [0 0] x2 + [0
0] x3 + [2]
[1 0] [0 2] [0
2] [0]
[splitqs#3](x1, x2, x3, x4) = [2 0] x1 + [0 2] x2 + [0
2] x3 + [3]
[1 1] [0 1] [0
2] [0]
[#and](x1, x2) = [0]
[3]
[#EQ] = [1]
[2]
[#GT] = [1]
[0]
[#LT] = [2]
[1]
[#0] = [1]
[2]
[#neg](x1) = [1 0] x1 + [0]
[0 1] [2]
[#pos](x1) = [0 1] x1 + [1]
[0 1] [2]
[#s](x1) = [1 0] x1 + [0]
[0 1] [0]
[#equal^#](x1, x2) = [0]
[0]
[#eq^#](x1, x2) = [0]
[0]
[#greater^#](x1, x2) = [0]
[0]
[#ckgt^#](x1) = [0]
[0]
[#compare^#](x1, x2) = [0]
[0]
[append^#](x1, x2) = [0]
[0]
[append#1^#](x1, x2) = [0]
[0]
[insert^#](x1, x2) = [0]
[0]
[insert#1^#](x1, x2, x3) = [0]
[0]
[insert#2^#](x1, x2, x3, x4) = [0]
[0]
[insert#3^#](x1, x2, x3, x4, x5) = [0]
[0]
[insert#4^#](x1, x2, x3, x4, x5, x6) = [0]
[0]
[quicksort^#](x1) = [0 2] x1 + [0]
[0 0] [0]
[quicksort#1^#](x1) = [0 2] x1 + [0]
[0 0] [0]
[quicksort#2^#](x1, x2) = [1 0] x1 + [0]
[0 0] [0]
[splitqs^#](x1, x2) = [0]
[0]
[splitqs#1^#](x1, x2) = [0]
[0]
[sortAll^#](x1) = [1 0] x1 + [1]
[0 0] [0]
[sortAll#1^#](x1) = [1 0] x1 + [1]
[0 0] [0]
[sortAll#2^#](x1, x2) = [0 2] x1 + [1 0] x2 + [1]
[0 0] [0 0] [0]
[split^#](x1) = [0]
[0]
[split#1^#](x1) = [0]
[0]
[splitAndSort^#](x1) = [3 3] x1 + [3]
[3 3] [3]
[splitqs#2^#](x1, x2, x3) = [0]
[0]
[splitqs#3^#](x1, x2, x3, x4) = [0]
[0]
[#and^#](x1, x2) = [0]
[0]
[c_1](x1, x2, x3) = [0]
[0]
[c] = [0]
[0]
[c_1](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
[0 0] [0 0] [0]
This order satisfies following ordering constraints
[#equal(@x, @y)] = [0 0] @x + [3 0] @y + [3]
[1 3] [2 0] [3]
>= [3]
[3]
= [#eq(@x, @y)]
[#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [3]
[3]
> [0]
[3]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(::(@x_1, @x_2), nil())] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2))] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(nil(), ::(@y_1, @y_2))] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(nil(), nil())] = [3]
[3]
> [0]
[1]
= [#true()]
[#eq(nil(), tuple#2(@y_1, @y_2))] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2))] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), nil())] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2))] = [3]
[3]
> [0]
[3]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(#0(), #0())] = [3]
[3]
> [0]
[1]
= [#true()]
[#eq(#0(), #neg(@y))] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(#0(), #pos(@y))] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(#0(), #s(@y))] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(#neg(@x), #0())] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(#neg(@x), #neg(@y))] = [3]
[3]
>= [3]
[3]
= [#eq(@x, @y)]
[#eq(#neg(@x), #pos(@y))] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(#pos(@x), #0())] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(#pos(@x), #neg(@y))] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(#pos(@x), #pos(@y))] = [3]
[3]
>= [3]
[3]
= [#eq(@x, @y)]
[#eq(#s(@x), #0())] = [3]
[3]
> [0]
[3]
= [#false()]
[#eq(#s(@x), #s(@y))] = [3]
[3]
>= [3]
[3]
= [#eq(@x, @y)]
[#greater(@x, @y)] = [0 0] @x + [0 0] @y + [0]
[0 2] [0 2] [1]
>= [0 0] @x + [0 0] @y + [0]
[0 2] [0 2] [1]
= [#ckgt(#compare(@x, @y))]
[#compare(#0(), #0())] = [5]
[4]
> [1]
[2]
= [#EQ()]
[#compare(#0(), #neg(@y))] = [0 1] @y + [5]
[0 1] [4]
> [1]
[0]
= [#GT()]
[#compare(#0(), #pos(@y))] = [0 1] @y + [5]
[0 1] [4]
> [2]
[1]
= [#LT()]
[#compare(#0(), #s(@y))] = [0 1] @y + [3]
[0 1] [2]
> [2]
[1]
= [#LT()]
[#compare(#neg(@x), #0())] = [0 1] @x + [5]
[0 1] [4]
> [2]
[1]
= [#LT()]
[#compare(#neg(@x), #neg(@y))] = [0 1] @x + [0 1] @y + [5]
[0 1] [0 1] [4]
> [0 1] @x + [0 1] @y + [1]
[0 1] [0 1] [0]
= [#compare(@y, @x)]
[#compare(#neg(@x), #pos(@y))] = [0 1] @x + [0 1] @y + [5]
[0 1] [0 1] [4]
> [2]
[1]
= [#LT()]
[#compare(#pos(@x), #0())] = [0 1] @x + [5]
[0 1] [4]
> [1]
[0]
= [#GT()]
[#compare(#pos(@x), #neg(@y))] = [0 1] @x + [0 1] @y + [5]
[0 1] [0 1] [4]
> [1]
[0]
= [#GT()]
[#compare(#pos(@x), #pos(@y))] = [0 1] @x + [0 1] @y + [5]
[0 1] [0 1] [4]
> [0 1] @x + [0 1] @y + [1]
[0 1] [0 1] [0]
= [#compare(@x, @y)]
[#compare(#s(@x), #0())] = [0 1] @x + [3]
[0 1] [2]
> [1]
[0]
= [#GT()]
[#compare(#s(@x), #s(@y))] = [0 1] @x + [0 1] @y + [1]
[0 1] [0 1] [0]
>= [0 1] @x + [0 1] @y + [1]
[0 1] [0 1] [0]
= [#compare(@x, @y)]
[#ckgt(#EQ())] = [0]
[3]
>= [0]
[3]
= [#false()]
[#ckgt(#GT())] = [0]
[1]
>= [0]
[1]
= [#true()]
[#ckgt(#LT())] = [0]
[3]
>= [0]
[3]
= [#false()]
[insert(@x, @l)] = [1 0] @l + [3]
[0 1] [1]
>= [1 0] @l + [3]
[0 1] [1]
= [insert#1(@x, @l, @x)]
[insert#1(tuple#2(@valX, @keyX), @l, @x)] = [1 0] @l + [3]
[0 1] [1]
>= [1 0] @l + [3]
[0 1] [1]
= [insert#2(@l, @keyX, @valX, @x)]
[insert#2(::(@l1, @ls), @keyX, @valX, @x)] = [0 2] @l1 + [1 0] @ls + [3]
[0 0] [0 1] [2]
>= [0 2] @l1 + [1 0] @ls + [3]
[0 0] [0 1] [2]
= [insert#3(@l1, @keyX, @ls, @valX, @x)]
[insert#2(nil(), @keyX, @valX, @x)] = [6]
[1]
> [5]
[1]
= [::(tuple#2(::(@valX, nil()), @keyX), nil())]
[insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x)] = [1 0] @ls + [0 2] @vals1 + [3]
[0 1] [0 0] [2]
>= [1 0] @ls + [0 2] @vals1 + [3]
[0 1] [0 0] [2]
= [insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)]
[insert#4(#false(), @key1, @ls, @valX, @vals1, @x)] = [1 0] @ls + [0 2] @vals1 + [3]
[0 1] [0 0] [2]
>= [1 0] @ls + [0 2] @vals1 + [3]
[0 1] [0 0] [2]
= [::(tuple#2(@vals1, @key1), insert(@x, @ls))]
[insert#4(#true(), @key1, @ls, @valX, @vals1, @x)] = [1 0] @ls + [0 2] @vals1 + [3]
[0 1] [0 0] [2]
> [1 0] @ls + [0 2] @vals1 + [2]
[0 1] [0 0] [1]
= [::(tuple#2(::(@valX, @vals1), @key1), @ls)]
[splitqs(@pivot, @l)] = [0 2] @l + [0 0] @pivot + [2]
[1 2] [0 2] [1]
>= [0 2] @l + [0 0] @pivot + [2]
[1 2] [0 2] [0]
= [splitqs#1(@l, @pivot)]
[split(@l)] = [1 3] @l + [1]
[1 1] [3]
>= [1 3] @l + [1]
[1 1] [3]
= [split#1(@l)]
[split#1(::(@x, @xs))] = [0 2] @x + [1 3] @xs + [4]
[0 2] [1 1] [4]
>= [1 3] @xs + [4]
[1 1] [4]
= [insert(@x, split(@xs))]
[split#1(nil())] = [4]
[6]
> [3]
[0]
= [nil()]
[splitqs#1(::(@x, @xs), @pivot)] = [0 0] @pivot + [0 0] @x + [0 2] @xs + [4]
[0 2] [0 2] [1 2] [2]
>= [0 0] @pivot + [0 0] @x + [0 2] @xs + [4]
[0 2] [0 2] [0 2] [2]
= [splitqs#2(splitqs(@pivot, @xs), @pivot, @x)]
[splitqs#1(nil(), @pivot)] = [0 0] @pivot + [2]
[0 2] [3]
> [1]
[0]
= [tuple#2(nil(), nil())]
[splitqs#2(tuple#2(@ls, @rs), @pivot, @x)] = [0 2] @ls + [0 0] @pivot + [0 2] @rs + [0 0] @x + [3]
[0 2] [0 2] [0 2] [0 2] [1]
>= [0 2] @ls + [0 0] @pivot + [0 2] @rs + [0 0] @x + [3]
[0 1] [0 2] [0 2] [0 2] [1]
= [splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)]
[splitqs#3(#false(), @ls, @rs, @x)] = [0 2] @ls + [0 2] @rs + [3]
[0 1] [0 2] [3]
>= [0 2] @ls + [0 2] @rs + [3]
[0 1] [0 0] [1]
= [tuple#2(::(@x, @ls), @rs)]
[splitqs#3(#true(), @ls, @rs, @x)] = [0 2] @ls + [0 2] @rs + [3]
[0 1] [0 2] [1]
>= [0 2] @ls + [0 2] @rs + [3]
[0 1] [0 0] [0]
= [tuple#2(@ls, ::(@x, @rs))]
[#and(#false(), #false())] = [0]
[3]
>= [0]
[3]
= [#false()]
[#and(#false(), #true())] = [0]
[3]
>= [0]
[3]
= [#false()]
[#and(#true(), #false())] = [0]
[3]
>= [0]
[3]
= [#false()]
[#and(#true(), #true())] = [0]
[3]
>= [0]
[1]
= [#true()]
[quicksort^#(@l)] = [0 2] @l + [0]
[0 0] [0]
>= [0 2] @l + [0]
[0 0] [0]
= [quicksort#1^#(@l)]
[quicksort#1^#(::(@z, @zs))] = [0 2] @zs + [2]
[0 0] [0]
>= [0 2] @zs + [2]
[0 0] [0]
= [quicksort#2^#(splitqs(@z, @zs), @z)]
[quicksort#2^#(tuple#2(@xs, @ys), @z)] = [0 2] @xs + [0 2] @ys + [1]
[0 0] [0 0] [0]
> [0 2] @xs + [0 2] @ys + [0]
[0 0] [0 0] [0]
= [c_1(quicksort^#(@xs), quicksort^#(@ys))]
[sortAll^#(@l)] = [1 0] @l + [1]
[0 0] [0]
>= [1 0] @l + [1]
[0 0] [0]
= [sortAll#1^#(@l)]
[sortAll#1^#(::(@x, @xs))] = [0 2] @x + [1 0] @xs + [1]
[0 0] [0 0] [0]
>= [0 2] @x + [1 0] @xs + [1]
[0 0] [0 0] [0]
= [sortAll#2^#(@x, @xs)]
[sortAll#2^#(tuple#2(@vals, @key), @xs)] = [0 2] @vals + [1 0] @xs + [1]
[0 0] [0 0] [0]
> [0 2] @vals + [0]
[0 0] [0]
= [quicksort^#(@vals)]
[sortAll#2^#(tuple#2(@vals, @key), @xs)] = [0 2] @vals + [1 0] @xs + [1]
[0 0] [0 0] [0]
>= [1 0] @xs + [1]
[0 0] [0]
= [sortAll^#(@xs)]
[splitAndSort^#(@l)] = [3 3] @l + [3]
[3 3] [3]
> [1 3] @l + [2]
[0 0] [0]
= [sortAll^#(split(@l))]
Processor 'matrix interpretation of dimension 2' induces the
complexity certificate YES(?,O(n^1)) on application of rules
{2,6,8}. Here rules are labeled according to the (estimated)
dependency graph
1: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z) :3
2: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys))
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :1
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
3: quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z)
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys)) :2
4: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :5
5: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs) :7
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
quicksort^#(@vals) :6
6: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
7: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :4
8: splitAndSort^#(@l) -> sortAll^#(split(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :4
- The rules {2,6,8} have known complexity. These cover all
predecessors of {1}, their complexity is equally bounded.
- The rules {1,2,6,8} have known complexity. These cover all
predecessors of {3}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules
{1,2,3,6,8} is given by YES(?,O(n^1)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{8} Weak SCC
|
`->2:{4,7,5} Weak SCC
|
`->3:{6} Weak SCC
|
`->4:{1,3,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: quicksort^#(@l) -> quicksort#1^#(@l)
, 2: quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z)
, 3: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys))
, 4: sortAll^#(@l) -> sortAll#1^#(@l)
, 5: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, 6: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, 7: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, 8: splitAndSort^#(@l) -> sortAll^#(split(@l)) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 8: splitAndSort^#(@l) -> sortAll^#(split(@l))
, 4: sortAll^#(@l) -> sortAll#1^#(@l)
, 7: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, 5: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, 6: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, 1: quicksort^#(@l) -> quicksort#1^#(@l)
, 3: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys))
, 2: quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z) }
We apply the transformation 'usablerules' on the sub-problem:
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
No rule is usable.
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
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 are left with following problem, upon which TcT provides the
certificate MAYBE.
Strict DPs: { append^#(@l, @ys) -> append#1^#(@l, @ys) }
Weak DPs:
{ append#1^#(::(@x, @xs), @ys) -> append^#(@xs, @ys)
, quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
append^#(quicksort(@xs), ::(@z, quicksort(@ys)))
, quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs)
, quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
MAYBE
None of the processors succeeded.
Details of failed attempt(s):
-----------------------------
1) 'empty' failed due to the following reason:
Empty strict component of the problem is NOT empty.
2) 'empty' failed due to the following reason:
Empty strict component of the problem is NOT empty.
* Path 1:{18}->3:{13,15,14}->4:{8,10,9}->5:{11,12}: YES(O(1),O(n^3))
------------------------------------------------------------------
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We consider the (estimated) dependency graph
1: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :2
2: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :4
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :3
3: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :1
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :1
4: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
-->_1 splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) :5
5: splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
-->_1 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :4
6: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :7
7: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :8
8: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :6
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
9: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :6
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {5} and add Pre({5}) = {4} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We consider the (estimated) dependency graph
1: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :2
2: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :4
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :3
3: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :1
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :1
4: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
-->_1 splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) :9
5: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :6
6: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :7
7: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :5
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
8: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :5
9: splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
-->_1 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :4
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We consider the (estimated) dependency graph
1: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :2
2: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :8
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :3
3: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
-->_1 splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) :9
4: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :5
5: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :6
6: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :4
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
7: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :4
8: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :1
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :1
9: splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
-->_1 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :3
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We consider the (estimated) dependency graph
1: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :7
2: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
-->_1 splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) :9
3: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :4
4: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :5
5: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :3
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
6: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :3
7: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :8
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :2
8: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :1
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :1
9: splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
-->_1 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :2
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {5} and add Pre({5}) = {4} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We consider the (estimated) dependency graph
1: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :6
2: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
-->_1 splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) :8
3: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :4
4: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :9
5: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :3
6: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :7
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :2
7: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :1
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :1
8: splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
-->_1 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :2
9: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :3
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {4} and add Pre({4}) = {3} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, sortAll^#(@l) -> sortAll#1^#(@l)
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We consider the (estimated) dependency graph
1: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :5
2: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
-->_1 splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) :7
3: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :8
4: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :3
5: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :6
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :2
6: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :1
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :1
7: splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
-->_1 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :2
8: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :9
9: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :3
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {4} and add Pre({4}) = {} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, sortAll^#(@l) -> sortAll#1^#(@l) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We consider the following dependency-graph
1: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :4
2: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
-->_1 splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) :6
3: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :7
4: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys)) :5
-->_2 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :2
5: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
-->_3 quicksort^#(@l) -> quicksort#1^#(@l) :1
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :1
6: splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
-->_1 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :2
7: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :8
8: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :3
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
9: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :3
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(append^#(quicksort(@xs), ::(@z, quicksort(@ys))),
quicksort^#(@xs),
quicksort^#(@ys))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, sortAll^#(@l) -> sortAll#1^#(@l) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys))
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^3)).
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, sortAll^#(@l) -> sortAll#1^#(@l) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys))
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^3))
We measure the number of applications of following selected rules
relative to the remaining rules.
Selected Rules (A):
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys))
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) }
Remaining Rules (B):
{ sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
The length of a single A-subderivation is expressed by the
following problem.
Problem (A):
------------
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys))
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
The number of B-applications is expressed by the following problem.
Problem (B):
------------
Strict DPs:
{ sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) }
Weak DPs:
{ sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
TcT answers on problem (B) 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:
{ sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) }
Weak DPs:
{ sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the following dependency-graph
1: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :3
2: sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs))
-->_2 sortAll^#(@l) -> sortAll#1^#(@l) :1
3: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) :2
4: splitAndSort^#(@l) -> sortAll^#(split(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ sortAll#2^#(tuple#2(@vals, @key), @xs) ->
c_3(quicksort^#(@vals), sortAll^#(@xs)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs) }
Weak DPs:
{ sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs) }
Weak DPs:
{ sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
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: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) }
Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(nil()) -> nil() }
Sub-proof:
----------
The following argument positions are usable:
Uargs(#equal) = {}, Uargs(#eq) = {}, Uargs(#greater) = {},
Uargs(#compare) = {}, Uargs(#ckgt) = {}, Uargs(::) = {},
Uargs(insert) = {}, Uargs(insert#1) = {}, Uargs(tuple#2) = {},
Uargs(insert#2) = {}, Uargs(insert#3) = {}, Uargs(insert#4) = {},
Uargs(splitqs) = {}, Uargs(split) = {}, Uargs(split#1) = {},
Uargs(splitqs#1) = {}, Uargs(splitqs#2) = {},
Uargs(splitqs#3) = {}, Uargs(#and) = {}, Uargs(#neg) = {},
Uargs(#pos) = {}, Uargs(#s) = {}, Uargs(#equal^#) = {},
Uargs(#eq^#) = {}, Uargs(#greater^#) = {}, Uargs(#ckgt^#) = {},
Uargs(#compare^#) = {}, Uargs(append^#) = {},
Uargs(append#1^#) = {}, Uargs(insert^#) = {},
Uargs(insert#1^#) = {}, Uargs(insert#2^#) = {},
Uargs(insert#3^#) = {}, Uargs(insert#4^#) = {},
Uargs(quicksort^#) = {}, Uargs(quicksort#1^#) = {},
Uargs(quicksort#2^#) = {}, Uargs(splitqs^#) = {},
Uargs(splitqs#1^#) = {}, Uargs(sortAll^#) = {},
Uargs(sortAll#1^#) = {}, Uargs(sortAll#2^#) = {},
Uargs(split^#) = {}, Uargs(split#1^#) = {},
Uargs(splitAndSort^#) = {}, Uargs(splitqs#2^#) = {},
Uargs(splitqs#3^#) = {}, Uargs(#and^#) = {}, Uargs(c_3) = {}
TcT has computed following constructor-based matrix interpretation
satisfying not(EDA).
[#equal](x1, x2) = [2] x1 + [2]
[#eq](x1, x2) = [0]
[#greater](x1, x2) = [0]
[#compare](x1, x2) = [0]
[#ckgt](x1) = [0]
[::](x1, x2) = [1] x1 + [1] x2 + [1]
[nil] = [3]
[insert](x1, x2) = [1] x2 + [2]
[insert#1](x1, x2, x3) = [1] x2 + [2]
[tuple#2](x1, x2) = [0]
[insert#2](x1, x2, x3, x4) = [1] x1 + [2]
[insert#3](x1, x2, x3, x4, x5) = [1] x3 + [3]
[insert#4](x1, x2, x3, x4, x5, x6) = [1] x3 + [3]
[#false] = [0]
[#true] = [0]
[splitqs](x1, x2) = [0]
[split](x1) = [3] x1 + [1]
[split#1](x1) = [3] x1 + [0]
[splitqs#1](x1, x2) = [0]
[splitqs#2](x1, x2, x3) = [0]
[splitqs#3](x1, x2, x3, x4) = [0]
[#and](x1, x2) = [0]
[#EQ] = [0]
[#GT] = [0]
[#LT] = [0]
[#0] = [0]
[#neg](x1) = [1] x1 + [0]
[#pos](x1) = [1] x1 + [0]
[#s](x1) = [1] x1 + [0]
[#equal^#](x1, x2) = [0]
[#eq^#](x1, x2) = [0]
[#greater^#](x1, x2) = [0]
[#ckgt^#](x1) = [0]
[#compare^#](x1, x2) = [0]
[append^#](x1, x2) = [0]
[append#1^#](x1, x2) = [0]
[insert^#](x1, x2) = [0]
[insert#1^#](x1, x2, x3) = [0]
[insert#2^#](x1, x2, x3, x4) = [0]
[insert#3^#](x1, x2, x3, x4, x5) = [0]
[insert#4^#](x1, x2, x3, x4, x5, x6) = [0]
[quicksort^#](x1) = [0]
[quicksort#1^#](x1) = [0]
[quicksort#2^#](x1, x2) = [0]
[splitqs^#](x1, x2) = [0]
[splitqs#1^#](x1, x2) = [0]
[sortAll^#](x1) = [1] x1 + [2]
[sortAll#1^#](x1) = [1] x1 + [2]
[sortAll#2^#](x1, x2) = [1] x2 + [2]
[split^#](x1) = [0]
[split#1^#](x1) = [0]
[splitAndSort^#](x1) = [3] x1 + [3]
[splitqs#2^#](x1, x2, x3) = [0]
[splitqs#3^#](x1, x2, x3, x4) = [0]
[#and^#](x1, x2) = [0]
[c_3](x1, x2) = [0]
[c] = [0]
This order satisfies following ordering constraints
[#equal(@x, @y)] = [2] @x + [2]
> [0]
= [#eq(@x, @y)]
[#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [0]
>= [0]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(::(@x_1, @x_2), nil())] = [0]
>= [0]
= [#false()]
[#eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2))] = [0]
>= [0]
= [#false()]
[#eq(nil(), ::(@y_1, @y_2))] = [0]
>= [0]
= [#false()]
[#eq(nil(), nil())] = [0]
>= [0]
= [#true()]
[#eq(nil(), tuple#2(@y_1, @y_2))] = [0]
>= [0]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2))] = [0]
>= [0]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), nil())] = [0]
>= [0]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2))] = [0]
>= [0]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(#0(), #0())] = [0]
>= [0]
= [#true()]
[#eq(#0(), #neg(@y))] = [0]
>= [0]
= [#false()]
[#eq(#0(), #pos(@y))] = [0]
>= [0]
= [#false()]
[#eq(#0(), #s(@y))] = [0]
>= [0]
= [#false()]
[#eq(#neg(@x), #0())] = [0]
>= [0]
= [#false()]
[#eq(#neg(@x), #neg(@y))] = [0]
>= [0]
= [#eq(@x, @y)]
[#eq(#neg(@x), #pos(@y))] = [0]
>= [0]
= [#false()]
[#eq(#pos(@x), #0())] = [0]
>= [0]
= [#false()]
[#eq(#pos(@x), #neg(@y))] = [0]
>= [0]
= [#false()]
[#eq(#pos(@x), #pos(@y))] = [0]
>= [0]
= [#eq(@x, @y)]
[#eq(#s(@x), #0())] = [0]
>= [0]
= [#false()]
[#eq(#s(@x), #s(@y))] = [0]
>= [0]
= [#eq(@x, @y)]
[insert(@x, @l)] = [1] @l + [2]
>= [1] @l + [2]
= [insert#1(@x, @l, @x)]
[insert#1(tuple#2(@valX, @keyX), @l, @x)] = [1] @l + [2]
>= [1] @l + [2]
= [insert#2(@l, @keyX, @valX, @x)]
[insert#2(::(@l1, @ls), @keyX, @valX, @x)] = [1] @l1 + [1] @ls + [3]
>= [1] @ls + [3]
= [insert#3(@l1, @keyX, @ls, @valX, @x)]
[insert#2(nil(), @keyX, @valX, @x)] = [5]
> [4]
= [::(tuple#2(::(@valX, nil()), @keyX), nil())]
[insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x)] = [1] @ls + [3]
>= [1] @ls + [3]
= [insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)]
[insert#4(#false(), @key1, @ls, @valX, @vals1, @x)] = [1] @ls + [3]
>= [1] @ls + [3]
= [::(tuple#2(@vals1, @key1), insert(@x, @ls))]
[insert#4(#true(), @key1, @ls, @valX, @vals1, @x)] = [1] @ls + [3]
> [1] @ls + [1]
= [::(tuple#2(::(@valX, @vals1), @key1), @ls)]
[split(@l)] = [3] @l + [1]
> [3] @l + [0]
= [split#1(@l)]
[split#1(::(@x, @xs))] = [3] @x + [3] @xs + [3]
>= [3] @xs + [3]
= [insert(@x, split(@xs))]
[split#1(nil())] = [9]
> [3]
= [nil()]
[#and(#false(), #false())] = [0]
>= [0]
= [#false()]
[#and(#false(), #true())] = [0]
>= [0]
= [#false()]
[#and(#true(), #false())] = [0]
>= [0]
= [#false()]
[#and(#true(), #true())] = [0]
>= [0]
= [#true()]
[sortAll^#(@l)] = [1] @l + [2]
>= [1] @l + [2]
= [sortAll#1^#(@l)]
[sortAll#1^#(::(@x, @xs))] = [1] @x + [1] @xs + [3]
> [1] @xs + [2]
= [sortAll#2^#(@x, @xs)]
[sortAll#2^#(tuple#2(@vals, @key), @xs)] = [1] @xs + [2]
>= [1] @xs + [2]
= [sortAll^#(@xs)]
[splitAndSort^#(@l)] = [3] @l + [3]
>= [3] @l + [3]
= [sortAll^#(split(@l))]
Processor 'matrix interpretation of dimension 1' induces the
complexity certificate YES(?,O(n^1)) on application of rules {3}.
Here rules are labeled according to the (estimated) dependency
graph
1: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :3
2: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :1
3: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs) :2
4: splitAndSort^#(@l) -> sortAll^#(split(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :1
- The rules {3} have known complexity. These cover all predecessors
of {2,4}, their complexity is equally bounded.
- The rules {2,3,4} have known complexity. These cover all
predecessors of {1}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules
{1,2,3,4} is given by YES(?,O(n^1)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{4} Weak SCC
|
`->2:{1,3,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: sortAll^#(@l) -> sortAll#1^#(@l)
, 2: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, 3: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, 4: splitAndSort^#(@l) -> sortAll^#(split(@l)) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 4: splitAndSort^#(@l) -> sortAll^#(split(@l))
, 1: sortAll^#(@l) -> sortAll#1^#(@l)
, 3: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, 2: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) }
We apply the transformation 'usablerules' on the sub-problem:
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
No rule is usable.
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
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 are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys))
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We measure the number of applications of following selected rules
relative to the remaining rules.
Selected Rules (A):
{ splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) }
Remaining Rules (B):
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
The length of a single A-subderivation is expressed by the
following problem.
Problem (A):
------------
Strict DPs: { splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) }
Weak DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#1^#(::(@z, @zs)) -> splitqs^#(@z, @zs)
, quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs)
, quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys)
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
The number of B-applications is expressed by the following problem.
Problem (B):
------------
Strict DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) }
Weak DPs:
{ quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
TcT answers on problem (B) 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:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) }
Weak DPs:
{ quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the (estimated) dependency graph
1: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :2
2: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys)) :3
3: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys))
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :1
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
4: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :5
5: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs) :7
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
quicksort^#(@vals) :6
6: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
7: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :4
8: splitAndSort^#(@l) -> sortAll^#(split(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :4
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { quicksort^#(@l) -> quicksort#1^#(@l) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the following dependency-graph
1: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) :2
2: quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs))
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys)) :3
3: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_2(quicksort^#(@xs), quicksort^#(@ys))
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :1
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
4: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :5
5: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs) :7
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
quicksort^#(@vals) :6
6: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
7: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :4
8: splitAndSort^#(@l) -> sortAll^#(split(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :4
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ quicksort#1^#(::(@z, @zs)) ->
c_1(quicksort#2^#(splitqs(@z, @zs), @z), splitqs^#(@z, @zs)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { quicksort^#(@l) -> quicksort#1^#(@l) }
Weak DPs:
{ quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
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: quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z)
, 6: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, 8: splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Trs:
{ #eq(nil(), nil()) -> #true()
, #eq(#0(), #0()) -> #true()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#s(@x), #0()) -> #GT()
, #ckgt(#EQ()) -> #false()
, #ckgt(#LT()) -> #false()
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, #and(#true(), #true()) -> #true() }
Sub-proof:
----------
The following argument positions are usable:
Uargs(#equal) = {}, Uargs(#eq) = {}, Uargs(#greater) = {},
Uargs(#compare) = {}, Uargs(#ckgt) = {}, Uargs(::) = {},
Uargs(insert) = {}, Uargs(insert#1) = {}, Uargs(tuple#2) = {},
Uargs(insert#2) = {}, Uargs(insert#3) = {}, Uargs(insert#4) = {},
Uargs(splitqs) = {}, Uargs(split) = {}, Uargs(split#1) = {},
Uargs(splitqs#1) = {}, Uargs(splitqs#2) = {},
Uargs(splitqs#3) = {}, Uargs(#and) = {}, Uargs(#neg) = {},
Uargs(#pos) = {}, Uargs(#s) = {}, Uargs(#equal^#) = {},
Uargs(#eq^#) = {}, Uargs(#greater^#) = {}, Uargs(#ckgt^#) = {},
Uargs(#compare^#) = {}, Uargs(append^#) = {},
Uargs(append#1^#) = {}, Uargs(insert^#) = {},
Uargs(insert#1^#) = {}, Uargs(insert#2^#) = {},
Uargs(insert#3^#) = {}, Uargs(insert#4^#) = {},
Uargs(quicksort^#) = {}, Uargs(quicksort#1^#) = {},
Uargs(quicksort#2^#) = {}, Uargs(splitqs^#) = {},
Uargs(splitqs#1^#) = {}, Uargs(sortAll^#) = {},
Uargs(sortAll#1^#) = {}, Uargs(sortAll#2^#) = {},
Uargs(split^#) = {}, Uargs(split#1^#) = {},
Uargs(splitAndSort^#) = {}, Uargs(splitqs#2^#) = {},
Uargs(splitqs#3^#) = {}, Uargs(#and^#) = {}, Uargs(c_1) = {},
Uargs(c_2) = {}, Uargs(c_1) = {1, 2}
TcT has computed following constructor-based matrix interpretation
satisfying not(EDA) and not(IDA(1)).
[#equal](x1, x2) = [1]
[3]
[#eq](x1, x2) = [1]
[1]
[#greater](x1, x2) = [2 0] x1 + [0 1] x2 + [2]
[0 0] [1 0] [1]
[#compare](x1, x2) = [0 0] x1 + [0 0] x2 + [1]
[1 0] [0 1] [0]
[#ckgt](x1) = [2 1] x1 + [0]
[0 0] [1]
[::](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
[0 0] [0 1] [1]
[nil] = [0]
[0]
[insert](x1, x2) = [1 0] x2 + [1]
[0 1] [1]
[insert#1](x1, x2, x3) = [1 0] x2 + [1]
[0 1] [1]
[tuple#2](x1, x2) = [0 1] x1 + [0 0] x2 + [0]
[0 1] [0 1] [0]
[insert#2](x1, x2, x3, x4) = [1 0] x1 + [1]
[0 1] [1]
[insert#3](x1, x2, x3, x4, x5) = [1 0] x1 + [1 0] x3 + [1]
[0 0] [0 1] [2]
[insert#4](x1, x2, x3, x4, x5, x6) = [1 0] x3 + [0 1] x5 + [1]
[0 1] [0 0] [2]
[#false] = [1]
[1]
[#true] = [0]
[0]
[splitqs](x1, x2) = [1 1] x1 + [2 3] x2 + [0]
[0 0] [0 1] [0]
[split](x1) = [0 1] x1 + [0]
[0 1] [0]
[split#1](x1) = [0 1] x1 + [0]
[0 1] [0]
[splitqs#1](x1, x2) = [2 3] x1 + [1 1] x2 + [0]
[0 1] [0 0] [0]
[splitqs#2](x1, x2, x3) = [0 2] x1 + [1 1] x2 + [2
0] x3 + [3]
[0 1] [0 0] [0
0] [1]
[splitqs#3](x1, x2, x3, x4) = [1 1] x1 + [0 2] x2 + [0
0] x3 + [0]
[0 0] [0 1] [0
1] [1]
[#and](x1, x2) = [1]
[1]
[#EQ] = [1]
[2]
[#GT] = [0]
[0]
[#LT] = [1]
[0]
[#0] = [0]
[2]
[#neg](x1) = [0 1] x1 + [0]
[1 0] [0]
[#pos](x1) = [1 0] x1 + [0]
[0 1] [0]
[#s](x1) = [1 0] x1 + [0]
[0 1] [0]
[#equal^#](x1, x2) = [0]
[0]
[#eq^#](x1, x2) = [0]
[0]
[#greater^#](x1, x2) = [0]
[0]
[#ckgt^#](x1) = [0]
[0]
[#compare^#](x1, x2) = [0]
[0]
[append^#](x1, x2) = [0]
[0]
[append#1^#](x1, x2) = [0]
[0]
[insert^#](x1, x2) = [0]
[0]
[insert#1^#](x1, x2, x3) = [0]
[0]
[insert#2^#](x1, x2, x3, x4) = [0]
[0]
[insert#3^#](x1, x2, x3, x4, x5) = [0]
[0]
[insert#4^#](x1, x2, x3, x4, x5, x6) = [0]
[0]
[quicksort^#](x1) = [0 3] x1 + [0]
[0 0] [0]
[quicksort#1^#](x1) = [0 3] x1 + [0]
[0 0] [0]
[quicksort#2^#](x1, x2) = [0 3] x1 + [0]
[0 0] [0]
[splitqs^#](x1, x2) = [0]
[0]
[splitqs#1^#](x1, x2) = [0]
[0]
[sortAll^#](x1) = [3 0] x1 + [2]
[0 0] [0]
[sortAll#1^#](x1) = [3 0] x1 + [2]
[0 0] [0]
[sortAll#2^#](x1, x2) = [3 0] x1 + [3 0] x2 + [2]
[0 0] [0 0] [0]
[split^#](x1) = [0]
[0]
[split#1^#](x1) = [0]
[0]
[splitAndSort^#](x1) = [3 3] x1 + [3]
[3 3] [3]
[splitqs#2^#](x1, x2, x3) = [0]
[0]
[splitqs#3^#](x1, x2, x3, x4) = [0]
[0]
[#and^#](x1, x2) = [0]
[0]
[c_1](x1, x2) = [0]
[0]
[c_2](x1, x2) = [0]
[0]
[c] = [0]
[0]
[c_1](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
[0 0] [0 0] [0]
This order satisfies following ordering constraints
[#equal(@x, @y)] = [1]
[3]
>= [1]
[1]
= [#eq(@x, @y)]
[#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [1]
[1]
>= [1]
[1]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(::(@x_1, @x_2), nil())] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2))] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(nil(), ::(@y_1, @y_2))] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(nil(), nil())] = [1]
[1]
> [0]
[0]
= [#true()]
[#eq(nil(), tuple#2(@y_1, @y_2))] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2))] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), nil())] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2))] = [1]
[1]
>= [1]
[1]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(#0(), #0())] = [1]
[1]
> [0]
[0]
= [#true()]
[#eq(#0(), #neg(@y))] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(#0(), #pos(@y))] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(#0(), #s(@y))] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(#neg(@x), #0())] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(#neg(@x), #neg(@y))] = [1]
[1]
>= [1]
[1]
= [#eq(@x, @y)]
[#eq(#neg(@x), #pos(@y))] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(#pos(@x), #0())] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(#pos(@x), #neg(@y))] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(#pos(@x), #pos(@y))] = [1]
[1]
>= [1]
[1]
= [#eq(@x, @y)]
[#eq(#s(@x), #0())] = [1]
[1]
>= [1]
[1]
= [#false()]
[#eq(#s(@x), #s(@y))] = [1]
[1]
>= [1]
[1]
= [#eq(@x, @y)]
[#greater(@x, @y)] = [2 0] @x + [0 1] @y + [2]
[0 0] [1 0] [1]
>= [1 0] @x + [0 1] @y + [2]
[0 0] [0 0] [1]
= [#ckgt(#compare(@x, @y))]
[#compare(#0(), #0())] = [1]
[2]
>= [1]
[2]
= [#EQ()]
[#compare(#0(), #neg(@y))] = [0 0] @y + [1]
[1 0] [0]
> [0]
[0]
= [#GT()]
[#compare(#0(), #pos(@y))] = [0 0] @y + [1]
[0 1] [0]
>= [1]
[0]
= [#LT()]
[#compare(#0(), #s(@y))] = [0 0] @y + [1]
[0 1] [0]
>= [1]
[0]
= [#LT()]
[#compare(#neg(@x), #0())] = [0 0] @x + [1]
[0 1] [2]
>= [1]
[0]
= [#LT()]
[#compare(#neg(@x), #neg(@y))] = [0 0] @x + [0 0] @y + [1]
[0 1] [1 0] [0]
>= [0 0] @x + [0 0] @y + [1]
[0 1] [1 0] [0]
= [#compare(@y, @x)]
[#compare(#neg(@x), #pos(@y))] = [0 0] @x + [0 0] @y + [1]
[0 1] [0 1] [0]
>= [1]
[0]
= [#LT()]
[#compare(#pos(@x), #0())] = [0 0] @x + [1]
[1 0] [2]
> [0]
[0]
= [#GT()]
[#compare(#pos(@x), #neg(@y))] = [0 0] @x + [0 0] @y + [1]
[1 0] [1 0] [0]
> [0]
[0]
= [#GT()]
[#compare(#pos(@x), #pos(@y))] = [0 0] @x + [0 0] @y + [1]
[1 0] [0 1] [0]
>= [0 0] @x + [0 0] @y + [1]
[1 0] [0 1] [0]
= [#compare(@x, @y)]
[#compare(#s(@x), #0())] = [0 0] @x + [1]
[1 0] [2]
> [0]
[0]
= [#GT()]
[#compare(#s(@x), #s(@y))] = [0 0] @x + [0 0] @y + [1]
[1 0] [0 1] [0]
>= [0 0] @x + [0 0] @y + [1]
[1 0] [0 1] [0]
= [#compare(@x, @y)]
[#ckgt(#EQ())] = [4]
[1]
> [1]
[1]
= [#false()]
[#ckgt(#GT())] = [0]
[1]
>= [0]
[0]
= [#true()]
[#ckgt(#LT())] = [2]
[1]
> [1]
[1]
= [#false()]
[insert(@x, @l)] = [1 0] @l + [1]
[0 1] [1]
>= [1 0] @l + [1]
[0 1] [1]
= [insert#1(@x, @l, @x)]
[insert#1(tuple#2(@valX, @keyX), @l, @x)] = [1 0] @l + [1]
[0 1] [1]
>= [1 0] @l + [1]
[0 1] [1]
= [insert#2(@l, @keyX, @valX, @x)]
[insert#2(::(@l1, @ls), @keyX, @valX, @x)] = [1 0] @l1 + [1 0] @ls + [1]
[0 0] [0 1] [2]
>= [1 0] @l1 + [1 0] @ls + [1]
[0 0] [0 1] [2]
= [insert#3(@l1, @keyX, @ls, @valX, @x)]
[insert#2(nil(), @keyX, @valX, @x)] = [1]
[1]
>= [1]
[1]
= [::(tuple#2(::(@valX, nil()), @keyX), nil())]
[insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x)] = [1 0] @ls + [0 1] @vals1 + [1]
[0 1] [0 0] [2]
>= [1 0] @ls + [0 1] @vals1 + [1]
[0 1] [0 0] [2]
= [insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)]
[insert#4(#false(), @key1, @ls, @valX, @vals1, @x)] = [1 0] @ls + [0 1] @vals1 + [1]
[0 1] [0 0] [2]
>= [1 0] @ls + [0 1] @vals1 + [1]
[0 1] [0 0] [2]
= [::(tuple#2(@vals1, @key1), insert(@x, @ls))]
[insert#4(#true(), @key1, @ls, @valX, @vals1, @x)] = [1 0] @ls + [0 1] @vals1 + [1]
[0 1] [0 0] [2]
>= [1 0] @ls + [0 1] @vals1 + [1]
[0 1] [0 0] [1]
= [::(tuple#2(::(@valX, @vals1), @key1), @ls)]
[splitqs(@pivot, @l)] = [2 3] @l + [1 1] @pivot + [0]
[0 1] [0 0] [0]
>= [2 3] @l + [1 1] @pivot + [0]
[0 1] [0 0] [0]
= [splitqs#1(@l, @pivot)]
[split(@l)] = [0 1] @l + [0]
[0 1] [0]
>= [0 1] @l + [0]
[0 1] [0]
= [split#1(@l)]
[split#1(::(@x, @xs))] = [0 1] @xs + [1]
[0 1] [1]
>= [0 1] @xs + [1]
[0 1] [1]
= [insert(@x, split(@xs))]
[split#1(nil())] = [0]
[0]
>= [0]
[0]
= [nil()]
[splitqs#1(::(@x, @xs), @pivot)] = [1 1] @pivot + [2 0] @x + [2 3] @xs + [3]
[0 0] [0 0] [0 1] [1]
>= [1 1] @pivot + [2 0] @x + [0 2] @xs + [3]
[0 0] [0 0] [0 1] [1]
= [splitqs#2(splitqs(@pivot, @xs), @pivot, @x)]
[splitqs#1(nil(), @pivot)] = [1 1] @pivot + [0]
[0 0] [0]
>= [0]
[0]
= [tuple#2(nil(), nil())]
[splitqs#2(tuple#2(@ls, @rs), @pivot, @x)] = [0 2] @ls + [1 1] @pivot + [0 2] @rs + [2 0] @x + [3]
[0 1] [0 0] [0 1] [0 0] [1]
>= [0 2] @ls + [1 1] @pivot + [0 0] @rs + [2 0] @x + [3]
[0 1] [0 0] [0 1] [0 0] [1]
= [splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)]
[splitqs#3(#false(), @ls, @rs, @x)] = [0 2] @ls + [0 0] @rs + [2]
[0 1] [0 1] [1]
> [0 1] @ls + [0 0] @rs + [1]
[0 1] [0 1] [1]
= [tuple#2(::(@x, @ls), @rs)]
[splitqs#3(#true(), @ls, @rs, @x)] = [0 2] @ls + [0 0] @rs + [0]
[0 1] [0 1] [1]
>= [0 1] @ls + [0 0] @rs + [0]
[0 1] [0 1] [1]
= [tuple#2(@ls, ::(@x, @rs))]
[#and(#false(), #false())] = [1]
[1]
>= [1]
[1]
= [#false()]
[#and(#false(), #true())] = [1]
[1]
>= [1]
[1]
= [#false()]
[#and(#true(), #false())] = [1]
[1]
>= [1]
[1]
= [#false()]
[#and(#true(), #true())] = [1]
[1]
> [0]
[0]
= [#true()]
[quicksort^#(@l)] = [0 3] @l + [0]
[0 0] [0]
>= [0 3] @l + [0]
[0 0] [0]
= [quicksort#1^#(@l)]
[quicksort#1^#(::(@z, @zs))] = [0 3] @zs + [3]
[0 0] [0]
> [0 3] @zs + [0]
[0 0] [0]
= [quicksort#2^#(splitqs(@z, @zs), @z)]
[quicksort#2^#(tuple#2(@xs, @ys), @z)] = [0 3] @xs + [0 3] @ys + [0]
[0 0] [0 0] [0]
>= [0 3] @xs + [0 3] @ys + [0]
[0 0] [0 0] [0]
= [c_1(quicksort^#(@xs), quicksort^#(@ys))]
[sortAll^#(@l)] = [3 0] @l + [2]
[0 0] [0]
>= [3 0] @l + [2]
[0 0] [0]
= [sortAll#1^#(@l)]
[sortAll#1^#(::(@x, @xs))] = [3 0] @x + [3 0] @xs + [2]
[0 0] [0 0] [0]
>= [3 0] @x + [3 0] @xs + [2]
[0 0] [0 0] [0]
= [sortAll#2^#(@x, @xs)]
[sortAll#2^#(tuple#2(@vals, @key), @xs)] = [0 3] @vals + [3 0] @xs + [2]
[0 0] [0 0] [0]
> [0 3] @vals + [0]
[0 0] [0]
= [quicksort^#(@vals)]
[sortAll#2^#(tuple#2(@vals, @key), @xs)] = [0 3] @vals + [3 0] @xs + [2]
[0 0] [0 0] [0]
>= [3 0] @xs + [2]
[0 0] [0]
= [sortAll^#(@xs)]
[splitAndSort^#(@l)] = [3 3] @l + [3]
[3 3] [3]
> [0 3] @l + [2]
[0 0] [0]
= [sortAll^#(split(@l))]
Processor 'matrix interpretation of dimension 2' induces the
complexity certificate YES(?,O(n^1)) on application of rules
{2,6,8}. Here rules are labeled according to the (estimated)
dependency graph
1: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z) :2
2: quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z)
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys)) :3
3: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys))
-->_2 quicksort^#(@l) -> quicksort#1^#(@l) :1
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
4: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :5
5: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs) :7
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
quicksort^#(@vals) :6
6: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :1
7: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :4
8: splitAndSort^#(@l) -> sortAll^#(split(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :4
- The rules {2,6,8} have known complexity. These cover all
predecessors of {3}, their complexity is equally bounded.
- The rules {2,3,6,8} have known complexity. These cover all
predecessors of {1}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules
{1,2,3,6,8} is given by YES(?,O(n^1)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys))
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{8} Weak SCC
|
`->2:{4,7,5} Weak SCC
|
`->3:{6} Weak SCC
|
`->4:{1,3,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: quicksort^#(@l) -> quicksort#1^#(@l)
, 2: quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z)
, 3: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys))
, 4: sortAll^#(@l) -> sortAll#1^#(@l)
, 5: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, 6: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, 7: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, 8: splitAndSort^#(@l) -> sortAll^#(split(@l)) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 8: splitAndSort^#(@l) -> sortAll^#(split(@l))
, 4: sortAll^#(@l) -> sortAll#1^#(@l)
, 7: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, 5: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, 6: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, 1: quicksort^#(@l) -> quicksort#1^#(@l)
, 3: quicksort#2^#(tuple#2(@xs, @ys), @z) ->
c_1(quicksort^#(@xs), quicksort^#(@ys))
, 2: quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z) }
We apply the transformation 'usablerules' on the sub-problem:
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
No rule is usable.
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
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 are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) }
Weak DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#1^#(::(@z, @zs)) -> splitqs^#(@z, @zs)
, quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs)
, quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys)
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
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:
{ 4: quicksort#1^#(::(@z, @zs)) -> splitqs^#(@z, @zs)
, 7: splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, 11: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, 12: splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Trs:
{ #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#LT()) -> #false()
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split#1(nil()) -> nil()
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs)) }
Sub-proof:
----------
The following argument positions are usable:
Uargs(#equal) = {}, Uargs(#eq) = {}, Uargs(#greater) = {},
Uargs(#compare) = {}, Uargs(#ckgt) = {}, Uargs(::) = {},
Uargs(insert) = {}, Uargs(insert#1) = {}, Uargs(tuple#2) = {},
Uargs(insert#2) = {}, Uargs(insert#3) = {}, Uargs(insert#4) = {},
Uargs(splitqs) = {}, Uargs(split) = {}, Uargs(split#1) = {},
Uargs(splitqs#1) = {}, Uargs(splitqs#2) = {},
Uargs(splitqs#3) = {}, Uargs(#and) = {}, Uargs(#neg) = {},
Uargs(#pos) = {}, Uargs(#s) = {}, Uargs(#equal^#) = {},
Uargs(#eq^#) = {}, Uargs(#greater^#) = {}, Uargs(#ckgt^#) = {},
Uargs(#compare^#) = {}, Uargs(append^#) = {},
Uargs(append#1^#) = {}, Uargs(insert^#) = {},
Uargs(insert#1^#) = {}, Uargs(insert#2^#) = {},
Uargs(insert#3^#) = {}, Uargs(insert#4^#) = {},
Uargs(quicksort^#) = {}, Uargs(quicksort#1^#) = {},
Uargs(quicksort#2^#) = {}, Uargs(splitqs^#) = {},
Uargs(splitqs#1^#) = {}, Uargs(sortAll^#) = {},
Uargs(sortAll#1^#) = {}, Uargs(sortAll#2^#) = {},
Uargs(split^#) = {}, Uargs(split#1^#) = {},
Uargs(splitAndSort^#) = {}, Uargs(splitqs#2^#) = {},
Uargs(splitqs#3^#) = {}, Uargs(#and^#) = {}
TcT has computed following constructor-based matrix interpretation
satisfying not(EDA) and not(IDA(1)).
[#equal](x1, x2) = [0 0] x1 + [0 0] x2 + [1]
[2 2] [2 0] [2]
[#eq](x1, x2) = [0 0] x1 + [0 0] x2 + [1]
[2 2] [2 0] [2]
[#greater](x1, x2) = [1 2] x1 + [1 2] x2 + [2]
[2 3] [2 3] [3]
[#compare](x1, x2) = [1 1] x1 + [1 1] x2 + [0]
[0 0] [0 0] [1]
[#ckgt](x1) = [1 1] x1 + [0]
[2 1] [1]
[::](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
[0 0] [0 1] [1]
[nil] = [1]
[1]
[insert](x1, x2) = [1 0] x2 + [3]
[0 1] [1]
[insert#1](x1, x2, x3) = [1 0] x2 + [3]
[0 1] [1]
[tuple#2](x1, x2) = [0 1] x1 + [0 0] x2 + [1]
[0 1] [0 1] [1]
[insert#2](x1, x2, x3, x4) = [1 0] x1 + [3]
[0 1] [1]
[insert#3](x1, x2, x3, x4, x5) = [1 0] x1 + [1 0] x3 + [3]
[0 0] [0 1] [2]
[insert#4](x1, x2, x3, x4, x5, x6) = [1 0] x1 + [1 0] x3 + [0
1] x5 + [3]
[0 0] [0 1] [0
0] [2]
[#false] = [1]
[3]
[#true] = [1]
[0]
[splitqs](x1, x2) = [1 1] x2 + [1]
[0 1] [2]
[split](x1) = [2 3] x1 + [2]
[0 2] [1]
[split#1](x1) = [2 3] x1 + [2]
[0 2] [1]
[splitqs#1](x1, x2) = [1 1] x1 + [1]
[0 1] [2]
[splitqs#2](x1, x2, x3) = [1 0] x1 + [1 0] x3 + [1]
[0 1] [0 0] [1]
[splitqs#3](x1, x2, x3, x4) = [0 1] x2 + [0 0] x3 + [1
0] x4 + [2]
[0 1] [0 1] [0
0] [2]
[#and](x1, x2) = [0 0] x1 + [0 0] x2 + [1]
[1 0] [1 0] [1]
[#EQ] = [2]
[1]
[#GT] = [1]
[0]
[#LT] = [2]
[0]
[#0] = [2]
[2]
[#neg](x1) = [1 0] x1 + [0]
[0 1] [2]
[#pos](x1) = [1 0] x1 + [0]
[0 1] [1]
[#s](x1) = [1 0] x1 + [0]
[0 1] [2]
[#equal^#](x1, x2) = [0]
[0]
[#eq^#](x1, x2) = [0]
[0]
[#greater^#](x1, x2) = [0]
[0]
[#ckgt^#](x1) = [0]
[0]
[#compare^#](x1, x2) = [0]
[0]
[append^#](x1, x2) = [0]
[0]
[append#1^#](x1, x2) = [0]
[0]
[insert^#](x1, x2) = [0]
[0]
[insert#1^#](x1, x2, x3) = [0]
[0]
[insert#2^#](x1, x2, x3, x4) = [0]
[0]
[insert#3^#](x1, x2, x3, x4, x5) = [0]
[0]
[insert#4^#](x1, x2, x3, x4, x5, x6) = [0]
[0]
[quicksort^#](x1) = [0 1] x1 + [1]
[0 0] [0]
[quicksort#1^#](x1) = [0 1] x1 + [1]
[0 0] [0]
[quicksort#2^#](x1, x2) = [0 1] x1 + [0]
[0 0] [0]
[splitqs^#](x1, x2) = [0 1] x2 + [0]
[0 0] [0]
[splitqs#1^#](x1, x2) = [0 1] x1 + [0]
[0 0] [0]
[sortAll^#](x1) = [1 0] x1 + [0]
[0 0] [0]
[sortAll#1^#](x1) = [1 0] x1 + [0]
[0 0] [0]
[sortAll#2^#](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
[0 0] [0 0] [0]
[split^#](x1) = [0]
[0]
[split#1^#](x1) = [0]
[0]
[splitAndSort^#](x1) = [3 3] x1 + [3]
[3 3] [3]
[splitqs#2^#](x1, x2, x3) = [0]
[0]
[splitqs#3^#](x1, x2, x3, x4) = [0]
[0]
[#and^#](x1, x2) = [0]
[0]
This order satisfies following ordering constraints
[#equal(@x, @y)] = [0 0] @x + [0 0] @y + [1]
[2 2] [2 0] [2]
>= [0 0] @x + [0 0] @y + [1]
[2 2] [2 0] [2]
= [#eq(@x, @y)]
[#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [0 0] @x_1 + [0 0] @x_2 + [0 0] @y_1 + [0 0] @y_2 + [1]
[2 0] [2 2] [2 0] [2 0] [4]
>= [1]
[3]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(::(@x_1, @x_2), nil())] = [0 0] @x_1 + [0 0] @x_2 + [1]
[2 0] [2 2] [6]
>= [1]
[3]
= [#false()]
[#eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2))] = [0 0] @x_1 + [0 0] @x_2 + [0 0] @y_1 + [1]
[2 0] [2 2] [0 2] [6]
>= [1]
[3]
= [#false()]
[#eq(nil(), ::(@y_1, @y_2))] = [0 0] @y_1 + [0 0] @y_2 + [1]
[2 0] [2 0] [6]
>= [1]
[3]
= [#false()]
[#eq(nil(), nil())] = [1]
[8]
>= [1]
[0]
= [#true()]
[#eq(nil(), tuple#2(@y_1, @y_2))] = [0 0] @y_1 + [1]
[0 2] [8]
>= [1]
[3]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2))] = [0 0] @x_1 + [0 0] @x_2 + [0 0] @y_1 + [0 0] @y_2 + [1]
[0 4] [0 2] [2 0] [2 0] [6]
>= [1]
[3]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), nil())] = [0 0] @x_1 + [0 0] @x_2 + [1]
[0 4] [0 2] [8]
>= [1]
[3]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2))] = [0 0] @x_1 + [0 0] @x_2 + [0 0] @y_1 + [1]
[0 4] [0 2] [0 2] [8]
>= [1]
[3]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(#0(), #0())] = [1]
[14]
>= [1]
[0]
= [#true()]
[#eq(#0(), #neg(@y))] = [0 0] @y + [1]
[2 0] [10]
>= [1]
[3]
= [#false()]
[#eq(#0(), #pos(@y))] = [0 0] @y + [1]
[2 0] [10]
>= [1]
[3]
= [#false()]
[#eq(#0(), #s(@y))] = [0 0] @y + [1]
[2 0] [10]
>= [1]
[3]
= [#false()]
[#eq(#neg(@x), #0())] = [0 0] @x + [1]
[2 2] [10]
>= [1]
[3]
= [#false()]
[#eq(#neg(@x), #neg(@y))] = [0 0] @x + [0 0] @y + [1]
[2 2] [2 0] [6]
>= [0 0] @x + [0 0] @y + [1]
[2 2] [2 0] [2]
= [#eq(@x, @y)]
[#eq(#neg(@x), #pos(@y))] = [0 0] @x + [0 0] @y + [1]
[2 2] [2 0] [6]
>= [1]
[3]
= [#false()]
[#eq(#pos(@x), #0())] = [0 0] @x + [1]
[2 2] [8]
>= [1]
[3]
= [#false()]
[#eq(#pos(@x), #neg(@y))] = [0 0] @x + [0 0] @y + [1]
[2 2] [2 0] [4]
>= [1]
[3]
= [#false()]
[#eq(#pos(@x), #pos(@y))] = [0 0] @x + [0 0] @y + [1]
[2 2] [2 0] [4]
>= [0 0] @x + [0 0] @y + [1]
[2 2] [2 0] [2]
= [#eq(@x, @y)]
[#eq(#s(@x), #0())] = [0 0] @x + [1]
[2 2] [10]
>= [1]
[3]
= [#false()]
[#eq(#s(@x), #s(@y))] = [0 0] @x + [0 0] @y + [1]
[2 2] [2 0] [6]
>= [0 0] @x + [0 0] @y + [1]
[2 2] [2 0] [2]
= [#eq(@x, @y)]
[#greater(@x, @y)] = [1 2] @x + [1 2] @y + [2]
[2 3] [2 3] [3]
> [1 1] @x + [1 1] @y + [1]
[2 2] [2 2] [2]
= [#ckgt(#compare(@x, @y))]
[#compare(#0(), #0())] = [8]
[1]
> [2]
[1]
= [#EQ()]
[#compare(#0(), #neg(@y))] = [1 1] @y + [6]
[0 0] [1]
> [1]
[0]
= [#GT()]
[#compare(#0(), #pos(@y))] = [1 1] @y + [5]
[0 0] [1]
> [2]
[0]
= [#LT()]
[#compare(#0(), #s(@y))] = [1 1] @y + [6]
[0 0] [1]
> [2]
[0]
= [#LT()]
[#compare(#neg(@x), #0())] = [1 1] @x + [6]
[0 0] [1]
> [2]
[0]
= [#LT()]
[#compare(#neg(@x), #neg(@y))] = [1 1] @x + [1 1] @y + [4]
[0 0] [0 0] [1]
> [1 1] @x + [1 1] @y + [0]
[0 0] [0 0] [1]
= [#compare(@y, @x)]
[#compare(#neg(@x), #pos(@y))] = [1 1] @x + [1 1] @y + [3]
[0 0] [0 0] [1]
> [2]
[0]
= [#LT()]
[#compare(#pos(@x), #0())] = [1 1] @x + [5]
[0 0] [1]
> [1]
[0]
= [#GT()]
[#compare(#pos(@x), #neg(@y))] = [1 1] @x + [1 1] @y + [3]
[0 0] [0 0] [1]
> [1]
[0]
= [#GT()]
[#compare(#pos(@x), #pos(@y))] = [1 1] @x + [1 1] @y + [2]
[0 0] [0 0] [1]
> [1 1] @x + [1 1] @y + [0]
[0 0] [0 0] [1]
= [#compare(@x, @y)]
[#compare(#s(@x), #0())] = [1 1] @x + [6]
[0 0] [1]
> [1]
[0]
= [#GT()]
[#compare(#s(@x), #s(@y))] = [1 1] @x + [1 1] @y + [4]
[0 0] [0 0] [1]
> [1 1] @x + [1 1] @y + [0]
[0 0] [0 0] [1]
= [#compare(@x, @y)]
[#ckgt(#EQ())] = [3]
[6]
> [1]
[3]
= [#false()]
[#ckgt(#GT())] = [1]
[3]
>= [1]
[0]
= [#true()]
[#ckgt(#LT())] = [2]
[5]
> [1]
[3]
= [#false()]
[insert(@x, @l)] = [1 0] @l + [3]
[0 1] [1]
>= [1 0] @l + [3]
[0 1] [1]
= [insert#1(@x, @l, @x)]
[insert#1(tuple#2(@valX, @keyX), @l, @x)] = [1 0] @l + [3]
[0 1] [1]
>= [1 0] @l + [3]
[0 1] [1]
= [insert#2(@l, @keyX, @valX, @x)]
[insert#2(::(@l1, @ls), @keyX, @valX, @x)] = [1 0] @l1 + [1 0] @ls + [3]
[0 0] [0 1] [2]
>= [1 0] @l1 + [1 0] @ls + [3]
[0 0] [0 1] [2]
= [insert#3(@l1, @keyX, @ls, @valX, @x)]
[insert#2(nil(), @keyX, @valX, @x)] = [4]
[2]
>= [4]
[2]
= [::(tuple#2(::(@valX, nil()), @keyX), nil())]
[insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x)] = [1 0] @ls + [0 1] @vals1 + [4]
[0 1] [0 0] [2]
>= [1 0] @ls + [0 1] @vals1 + [4]
[0 1] [0 0] [2]
= [insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)]
[insert#4(#false(), @key1, @ls, @valX, @vals1, @x)] = [1 0] @ls + [0 1] @vals1 + [4]
[0 1] [0 0] [2]
>= [1 0] @ls + [0 1] @vals1 + [4]
[0 1] [0 0] [2]
= [::(tuple#2(@vals1, @key1), insert(@x, @ls))]
[insert#4(#true(), @key1, @ls, @valX, @vals1, @x)] = [1 0] @ls + [0 1] @vals1 + [4]
[0 1] [0 0] [2]
> [1 0] @ls + [0 1] @vals1 + [2]
[0 1] [0 0] [1]
= [::(tuple#2(::(@valX, @vals1), @key1), @ls)]
[splitqs(@pivot, @l)] = [1 1] @l + [1]
[0 1] [2]
>= [1 1] @l + [1]
[0 1] [2]
= [splitqs#1(@l, @pivot)]
[split(@l)] = [2 3] @l + [2]
[0 2] [1]
>= [2 3] @l + [2]
[0 2] [1]
= [split#1(@l)]
[split#1(::(@x, @xs))] = [2 0] @x + [2 3] @xs + [5]
[0 0] [0 2] [3]
>= [2 3] @xs + [5]
[0 2] [2]
= [insert(@x, split(@xs))]
[split#1(nil())] = [7]
[3]
> [1]
[1]
= [nil()]
[splitqs#1(::(@x, @xs), @pivot)] = [1 0] @x + [1 1] @xs + [2]
[0 0] [0 1] [3]
>= [1 0] @x + [1 1] @xs + [2]
[0 0] [0 1] [3]
= [splitqs#2(splitqs(@pivot, @xs), @pivot, @x)]
[splitqs#1(nil(), @pivot)] = [3]
[3]
> [2]
[3]
= [tuple#2(nil(), nil())]
[splitqs#2(tuple#2(@ls, @rs), @pivot, @x)] = [0 1] @ls + [0 0] @rs + [1 0] @x + [2]
[0 1] [0 1] [0 0] [2]
>= [0 1] @ls + [0 0] @rs + [1 0] @x + [2]
[0 1] [0 1] [0 0] [2]
= [splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)]
[splitqs#3(#false(), @ls, @rs, @x)] = [0 1] @ls + [0 0] @rs + [1 0] @x + [2]
[0 1] [0 1] [0 0] [2]
>= [0 1] @ls + [0 0] @rs + [2]
[0 1] [0 1] [2]
= [tuple#2(::(@x, @ls), @rs)]
[splitqs#3(#true(), @ls, @rs, @x)] = [0 1] @ls + [0 0] @rs + [1 0] @x + [2]
[0 1] [0 1] [0 0] [2]
> [0 1] @ls + [0 0] @rs + [1]
[0 1] [0 1] [2]
= [tuple#2(@ls, ::(@x, @rs))]
[#and(#false(), #false())] = [1]
[3]
>= [1]
[3]
= [#false()]
[#and(#false(), #true())] = [1]
[3]
>= [1]
[3]
= [#false()]
[#and(#true(), #false())] = [1]
[3]
>= [1]
[3]
= [#false()]
[#and(#true(), #true())] = [1]
[3]
>= [1]
[0]
= [#true()]
[quicksort^#(@l)] = [0 1] @l + [1]
[0 0] [0]
>= [0 1] @l + [1]
[0 0] [0]
= [quicksort#1^#(@l)]
[quicksort#1^#(::(@z, @zs))] = [0 1] @zs + [2]
[0 0] [0]
>= [0 1] @zs + [2]
[0 0] [0]
= [quicksort#2^#(splitqs(@z, @zs), @z)]
[quicksort#1^#(::(@z, @zs))] = [0 1] @zs + [2]
[0 0] [0]
> [0 1] @zs + [0]
[0 0] [0]
= [splitqs^#(@z, @zs)]
[quicksort#2^#(tuple#2(@xs, @ys), @z)] = [0 1] @xs + [0 1] @ys + [1]
[0 0] [0 0] [0]
>= [0 1] @xs + [1]
[0 0] [0]
= [quicksort^#(@xs)]
[quicksort#2^#(tuple#2(@xs, @ys), @z)] = [0 1] @xs + [0 1] @ys + [1]
[0 0] [0 0] [0]
>= [0 1] @ys + [1]
[0 0] [0]
= [quicksort^#(@ys)]
[splitqs^#(@pivot, @l)] = [0 1] @l + [0]
[0 0] [0]
>= [0 1] @l + [0]
[0 0] [0]
= [splitqs#1^#(@l, @pivot)]
[splitqs#1^#(::(@x, @xs), @pivot)] = [0 1] @xs + [1]
[0 0] [0]
> [0 1] @xs + [0]
[0 0] [0]
= [splitqs^#(@pivot, @xs)]
[sortAll^#(@l)] = [1 0] @l + [0]
[0 0] [0]
>= [1 0] @l + [0]
[0 0] [0]
= [sortAll#1^#(@l)]
[sortAll#1^#(::(@x, @xs))] = [1 0] @x + [1 0] @xs + [0]
[0 0] [0 0] [0]
>= [1 0] @x + [1 0] @xs + [0]
[0 0] [0 0] [0]
= [sortAll#2^#(@x, @xs)]
[sortAll#2^#(tuple#2(@vals, @key), @xs)] = [0 1] @vals + [1 0] @xs + [1]
[0 0] [0 0] [0]
>= [0 1] @vals + [1]
[0 0] [0]
= [quicksort^#(@vals)]
[sortAll#2^#(tuple#2(@vals, @key), @xs)] = [0 1] @vals + [1 0] @xs + [1]
[0 0] [0 0] [0]
> [1 0] @xs + [0]
[0 0] [0]
= [sortAll^#(@xs)]
[splitAndSort^#(@l)] = [3 3] @l + [3]
[3 3] [3]
> [2 3] @l + [2]
[0 0] [0]
= [sortAll^#(split(@l))]
Processor 'matrix interpretation of dimension 2' induces the
complexity certificate YES(?,O(n^1)) on application of rules
{4,7,11,12}. Here rules are labeled according to the (estimated)
dependency graph
1: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
-->_1 splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) :7
2: quicksort^#(@l) -> quicksort#1^#(@l)
-->_1 quicksort#1^#(::(@z, @zs)) -> splitqs^#(@z, @zs) :4
-->_1 quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z) :3
3: quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z)
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys) :6
-->_1 quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs) :5
4: quicksort#1^#(::(@z, @zs)) -> splitqs^#(@z, @zs)
-->_1 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :1
5: quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs)
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :2
6: quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys)
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :2
7: splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
-->_1 splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot) :1
8: sortAll^#(@l) -> sortAll#1^#(@l)
-->_1 sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs) :9
9: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs) :11
-->_1 sortAll#2^#(tuple#2(@vals, @key), @xs) ->
quicksort^#(@vals) :10
10: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
-->_1 quicksort^#(@l) -> quicksort#1^#(@l) :2
11: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :8
12: splitAndSort^#(@l) -> sortAll^#(split(@l))
-->_1 sortAll^#(@l) -> sortAll#1^#(@l) :8
- The rules {4,7,11,12} have known complexity. These cover all
predecessors of {1,8}, their complexity is equally bounded.
- The rules {1,4,7,8,11,12} have known complexity. These cover all
predecessors of {9}, their complexity is equally bounded.
- The rules {1,4,7,8,9,11,12} have known complexity. These cover
all predecessors of {10}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules
{1,4,7,8,9,10,11,12} is given by YES(?,O(n^1)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ quicksort^#(@l) -> quicksort#1^#(@l)
, quicksort#1^#(::(@z, @zs)) -> quicksort#2^#(splitqs(@z, @zs), @z)
, quicksort#1^#(::(@z, @zs)) -> splitqs^#(@z, @zs)
, quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs)
, quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys)
, splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, sortAll^#(@l) -> sortAll#1^#(@l)
, sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, splitAndSort^#(@l) -> sortAll^#(split(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{12} Weak SCC
|
`->2:{8,11,9} Weak SCC
|
`->3:{10} Weak SCC
|
`->4:{1,5,2,4} Weak SCC
|
`->5:{3} Weak SCC
|
`->6:{6,7} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: quicksort^#(@l) -> quicksort#1^#(@l)
, 2: quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z)
, 3: quicksort#1^#(::(@z, @zs)) -> splitqs^#(@z, @zs)
, 4: quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs)
, 5: quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys)
, 6: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, 7: splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs)
, 8: sortAll^#(@l) -> sortAll#1^#(@l)
, 9: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, 10: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, 11: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, 12: splitAndSort^#(@l) -> sortAll^#(split(@l)) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 12: splitAndSort^#(@l) -> sortAll^#(split(@l))
, 8: sortAll^#(@l) -> sortAll#1^#(@l)
, 11: sortAll#2^#(tuple#2(@vals, @key), @xs) -> sortAll^#(@xs)
, 9: sortAll#1^#(::(@x, @xs)) -> sortAll#2^#(@x, @xs)
, 10: sortAll#2^#(tuple#2(@vals, @key), @xs) -> quicksort^#(@vals)
, 1: quicksort^#(@l) -> quicksort#1^#(@l)
, 5: quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@ys)
, 2: quicksort#1^#(::(@z, @zs)) ->
quicksort#2^#(splitqs(@z, @zs), @z)
, 4: quicksort#2^#(tuple#2(@xs, @ys), @z) -> quicksort^#(@xs)
, 3: quicksort#1^#(::(@z, @zs)) -> splitqs^#(@z, @zs)
, 6: splitqs^#(@pivot, @l) -> splitqs#1^#(@l, @pivot)
, 7: splitqs#1^#(::(@x, @xs), @pivot) -> splitqs^#(@pivot, @xs) }
We apply the transformation 'usablerules' on the sub-problem:
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
No rule is usable.
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
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
* Path 1:{18}->2:{16,17}->6:{3,7,6,5,4}: YES(O(1),O(n^2))
-------------------------------------------------------
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the (estimated) dependency graph
1: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
-->_1 insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x) :2
2: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
-->_1 insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x) :3
3: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
-->_1 insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x) :4
4: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
-->_1 insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) :5
5: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
6: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs)) :7
7: split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
-->_2 split^#(@l) -> split#1^#(@l) :6
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
8: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_2 split^#(@l) -> split#1^#(@l) :6
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {5} and add Pre({5}) = {4} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the (estimated) dependency graph
1: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
-->_1 insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x) :2
2: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
-->_1 insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x) :3
3: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
-->_1 insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x) :4
4: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
-->_1 insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) :8
5: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs)) :6
6: split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
-->_2 split^#(@l) -> split#1^#(@l) :5
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
7: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_2 split^#(@l) -> split#1^#(@l) :5
8: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {4} and add Pre({4}) = {3} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the (estimated) dependency graph
1: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
-->_1 insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x) :2
2: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
-->_1 insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x) :3
3: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
-->_1 insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x) :7
4: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs)) :5
5: split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
-->_2 split^#(@l) -> split#1^#(@l) :4
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
6: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_2 split^#(@l) -> split#1^#(@l) :4
7: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
-->_1 insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) :8
8: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the (estimated) dependency graph
1: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
-->_1 insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x) :2
2: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
-->_1 insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x) :6
3: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs)) :4
4: split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
-->_2 split^#(@l) -> split#1^#(@l) :3
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
5: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_2 split^#(@l) -> split#1^#(@l) :3
6: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
-->_1 insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x) :7
7: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
-->_1 insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) :8
8: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the (estimated) dependency graph
1: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
-->_1 insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x) :5
2: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs)) :3
3: split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
-->_2 split^#(@l) -> split#1^#(@l) :2
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
4: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_2 split^#(@l) -> split#1^#(@l) :2
5: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
-->_1 insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x) :6
6: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
-->_1 insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x) :7
7: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
-->_1 insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) :8
8: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {2} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, split^#(@l) -> split#1^#(@l)
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak DPs:
{ insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the (estimated) dependency graph
1: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
-->_1 insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x) :4
2: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs)) :8
3: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_2 split^#(@l) -> split#1^#(@l) :2
4: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
-->_1 insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x) :5
5: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
-->_1 insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x) :6
6: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
-->_1 insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) :7
7: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
8: split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
-->_2 split^#(@l) -> split#1^#(@l) :2
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {3} and add Pre({3}) = {} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, split^#(@l) -> split#1^#(@l) }
Weak DPs:
{ insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We consider the following dependency-graph
1: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
-->_1 insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x) :3
2: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs)) :7
3: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
-->_1 insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x) :4
4: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
-->_1 insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x) :5
5: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
-->_1 insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) :6
6: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
7: split#1^#(::(@x, @xs)) ->
c_4(insert^#(@x, split(@xs)), split^#(@xs))
-->_2 split^#(@l) -> split#1^#(@l) :2
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
8: splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l))
-->_2 split^#(@l) -> split#1^#(@l) :2
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ splitAndSort^#(@l) -> c_5(sortAll^#(split(@l)), split^#(@l)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, split^#(@l) -> split#1^#(@l) }
Weak DPs:
{ insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, split#1^#(::(@x, @xs)) ->
c_1(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> split^#(@l) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, #greater(@x, @y) -> #ckgt(#compare(@x, @y))
, #compare(#0(), #0()) -> #EQ()
, #compare(#0(), #neg(@y)) -> #GT()
, #compare(#0(), #pos(@y)) -> #LT()
, #compare(#0(), #s(@y)) -> #LT()
, #compare(#neg(@x), #0()) -> #LT()
, #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
, #compare(#neg(@x), #pos(@y)) -> #LT()
, #compare(#pos(@x), #0()) -> #GT()
, #compare(#pos(@x), #neg(@y)) -> #GT()
, #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
, #compare(#s(@x), #0()) -> #GT()
, #compare(#s(@x), #s(@y)) -> #compare(@x, @y)
, #ckgt(#EQ()) -> #false()
, #ckgt(#GT()) -> #true()
, #ckgt(#LT()) -> #false()
, append(@l, @ys) -> append#1(@l, @ys)
, append#1(::(@x, @xs), @ys) -> ::(@x, append(@xs, @ys))
, append#1(nil(), @ys) -> @ys
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, quicksort(@l) -> quicksort#1(@l)
, quicksort#1(::(@z, @zs)) -> quicksort#2(splitqs(@z, @zs), @z)
, quicksort#1(nil()) -> nil()
, splitqs(@pivot, @l) -> splitqs#1(@l, @pivot)
, quicksort#2(tuple#2(@xs, @ys), @z) ->
append(quicksort(@xs), ::(@z, quicksort(@ys)))
, sortAll(@l) -> sortAll#1(@l)
, sortAll#1(::(@x, @xs)) -> sortAll#2(@x, @xs)
, sortAll#1(nil()) -> nil()
, sortAll#2(tuple#2(@vals, @key), @xs) ->
::(tuple#2(quicksort(@vals), @key), sortAll(@xs))
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, splitAndSort(@l) -> sortAll(split(@l))
, splitqs#1(::(@x, @xs), @pivot) ->
splitqs#2(splitqs(@pivot, @xs), @pivot, @x)
, splitqs#1(nil(), @pivot) -> tuple#2(nil(), nil())
, splitqs#2(tuple#2(@ls, @rs), @pivot, @x) ->
splitqs#3(#greater(@x, @pivot), @ls, @rs, @x)
, splitqs#3(#false(), @ls, @rs, @x) -> tuple#2(::(@x, @ls), @rs)
, splitqs#3(#true(), @ls, @rs, @x) -> tuple#2(@ls, ::(@x, @rs))
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We replace strict/weak-rules by the corresponding usable rules:
Weak Usable Rules:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).
Strict DPs:
{ insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, split^#(@l) -> split#1^#(@l) }
Weak DPs:
{ insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, split#1^#(::(@x, @xs)) ->
c_1(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> split^#(@l) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^2))
We measure the number of applications of following selected rules
relative to the remaining rules.
Selected Rules (A):
{ insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) }
Remaining Rules (B):
{ split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_1(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> split^#(@l) }
The length of a single A-subderivation is expressed by the
following problem.
Problem (A):
------------
Strict DPs: { insert^#(@x, @l) -> insert#1^#(@x, @l, @x) }
Weak DPs:
{ insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) -> insert^#(@x, split(@xs))
, split#1^#(::(@x, @xs)) -> split^#(@xs)
, splitAndSort^#(@l) -> split^#(@l) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
The number of B-applications is expressed by the following problem.
Problem (B):
------------
Strict DPs:
{ split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_1(insert^#(@x, split(@xs)), split^#(@xs)) }
Weak DPs: { splitAndSort^#(@l) -> split^#(@l) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
TcT answers on problem (B) 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:
{ split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) ->
c_1(insert^#(@x, split(@xs)), split^#(@xs)) }
Weak DPs: { splitAndSort^#(@l) -> split^#(@l) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the (estimated) dependency graph
1: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) ->
c_1(insert^#(@x, split(@xs)), split^#(@xs)) :2
2: split#1^#(::(@x, @xs)) ->
c_1(insert^#(@x, split(@xs)), split^#(@xs))
-->_2 split^#(@l) -> split#1^#(@l) :1
3: splitAndSort^#(@l) -> split^#(@l)
-->_1 split^#(@l) -> split#1^#(@l) :1
We estimate the application of rules based on the application of
their predecessors as follows:
- We remove {2} and add Pre({2}) = {1} to the strict component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { split^#(@l) -> split#1^#(@l) }
Weak DPs:
{ split#1^#(::(@x, @xs)) ->
c_1(insert^#(@x, split(@xs)), split^#(@xs))
, splitAndSort^#(@l) -> split^#(@l) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We consider the following dependency-graph
1: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) ->
c_1(insert^#(@x, split(@xs)), split^#(@xs)) :2
2: split#1^#(::(@x, @xs)) ->
c_1(insert^#(@x, split(@xs)), split^#(@xs))
-->_2 split^#(@l) -> split#1^#(@l) :1
3: splitAndSort^#(@l) -> split^#(@l)
-->_1 split^#(@l) -> split#1^#(@l) :1
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ split#1^#(::(@x, @xs)) ->
c_1(insert^#(@x, split(@xs)), split^#(@xs)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { split^#(@l) -> split#1^#(@l) }
Weak DPs:
{ split#1^#(::(@x, @xs)) -> split^#(@xs)
, splitAndSort^#(@l) -> split^#(@l) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
No rule is usable.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { split^#(@l) -> split#1^#(@l) }
Weak DPs:
{ split#1^#(::(@x, @xs)) -> split^#(@xs)
, splitAndSort^#(@l) -> split^#(@l) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We use the processor 'Small Polynomial Path Order (PS,1-bounded)'
to orient following rules strictly.
DPs:
{ 2: split#1^#(::(@x, @xs)) -> split^#(@xs)
, 3: splitAndSort^#(@l) -> split^#(@l) }
Sub-proof:
----------
The input was oriented with the instance of 'Small Polynomial Path
Order (PS,1-bounded)' as induced by the safe mapping
safe(#equal) = {}, safe(#eq) = {}, safe(::) = {1, 2},
safe(nil) = {}, safe(insert) = {}, safe(insert#1) = {},
safe(tuple#2) = {1, 2}, safe(insert#2) = {}, safe(insert#3) = {},
safe(insert#4) = {}, safe(#false) = {}, safe(#true) = {},
safe(split) = {}, safe(split#1) = {}, safe(#and) = {},
safe(#EQ) = {}, safe(#GT) = {}, safe(#LT) = {}, safe(#0) = {},
safe(#neg) = {1}, safe(#pos) = {1}, safe(#s) = {1},
safe(#equal^#) = {}, safe(#eq^#) = {}, safe(#greater^#) = {},
safe(#ckgt^#) = {}, safe(#compare^#) = {}, safe(append^#) = {},
safe(append#1^#) = {}, safe(insert^#) = {}, safe(insert#1^#) = {},
safe(insert#2^#) = {}, safe(insert#3^#) = {},
safe(insert#4^#) = {}, safe(quicksort^#) = {},
safe(quicksort#1^#) = {}, safe(quicksort#2^#) = {},
safe(splitqs^#) = {}, safe(splitqs#1^#) = {}, safe(sortAll^#) = {},
safe(sortAll#1^#) = {}, safe(sortAll#2^#) = {}, safe(split^#) = {},
safe(split#1^#) = {}, safe(splitAndSort^#) = {},
safe(splitqs#2^#) = {}, safe(splitqs#3^#) = {}, safe(#and^#) = {},
safe(c_1) = {}, safe(c) = {}
and precedence
empty .
Following symbols are considered recursive:
{}
The recursion depth is 0.
Further, following argument filtering is employed:
pi(#equal) = [], pi(#eq) = [], pi(::) = [2], pi(nil) = [],
pi(insert) = [], pi(insert#1) = [], pi(tuple#2) = [],
pi(insert#2) = [], pi(insert#3) = [], pi(insert#4) = [],
pi(#false) = [], pi(#true) = [], pi(split) = [], pi(split#1) = [],
pi(#and) = [], pi(#EQ) = [], pi(#GT) = [], pi(#LT) = [],
pi(#0) = [], pi(#neg) = [], pi(#pos) = [], pi(#s) = [],
pi(#equal^#) = [], pi(#eq^#) = [], pi(#greater^#) = [],
pi(#ckgt^#) = [], pi(#compare^#) = [], pi(append^#) = [],
pi(append#1^#) = [], pi(insert^#) = [], pi(insert#1^#) = [],
pi(insert#2^#) = [], pi(insert#3^#) = [], pi(insert#4^#) = [],
pi(quicksort^#) = [], pi(quicksort#1^#) = [],
pi(quicksort#2^#) = [], pi(splitqs^#) = [], pi(splitqs#1^#) = [],
pi(sortAll^#) = [], pi(sortAll#1^#) = [], pi(sortAll#2^#) = [],
pi(split^#) = 1, pi(split#1^#) = 1, pi(splitAndSort^#) = [1],
pi(splitqs#2^#) = [], pi(splitqs#3^#) = [], pi(#and^#) = [],
pi(c_1) = [], pi(c) = []
Usable defined function symbols are a subset of:
{}
For your convenience, here are the satisfied ordering constraints:
pi(split^#(@l)) = @l
>= @l
= pi(split#1^#(@l))
pi(split#1^#(::(@x, @xs))) = ::(; @xs)
> @xs
= pi(split^#(@xs))
pi(splitAndSort^#(@l)) = splitAndSort^#(@l;)
> @l
= pi(split^#(@l))
Processor 'Small Polynomial Path Order (PS,1-bounded)' induces the
complexity certificate YES(?,O(n^1)) on application of rules {2,3}.
Here rules are labeled according to the (estimated) dependency
graph
1: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) -> split^#(@xs) :2
2: split#1^#(::(@x, @xs)) -> split^#(@xs)
-->_1 split^#(@l) -> split#1^#(@l) :1
3: splitAndSort^#(@l) -> split^#(@l)
-->_1 split^#(@l) -> split#1^#(@l) :1
- The rules {2,3} have known complexity. These cover all
predecessors of {1}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules {1,2,3}
is given by YES(?,O(n^1)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) -> split^#(@xs)
, splitAndSort^#(@l) -> split^#(@l) }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{3} Weak SCC
|
`->2:{1,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: split^#(@l) -> split#1^#(@l)
, 2: split#1^#(::(@x, @xs)) -> split^#(@xs)
, 3: splitAndSort^#(@l) -> split^#(@l) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 3: splitAndSort^#(@l) -> split^#(@l)
, 1: split^#(@l) -> split#1^#(@l)
, 2: split#1^#(::(@x, @xs)) -> split^#(@xs) }
We apply the transformation 'usablerules' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
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 are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { insert^#(@x, @l) -> insert#1^#(@x, @l, @x) }
Weak DPs:
{ insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) -> insert^#(@x, split(@xs))
, split#1^#(::(@x, @xs)) -> split^#(@xs)
, splitAndSort^#(@l) -> split^#(@l) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
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: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, 7: split#1^#(::(@x, @xs)) -> insert^#(@x, split(@xs))
, 8: split#1^#(::(@x, @xs)) -> split^#(@xs)
, 9: splitAndSort^#(@l) -> split^#(@l) }
Trs:
{ insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil() }
Sub-proof:
----------
The following argument positions are usable:
Uargs(#equal) = {}, Uargs(#eq) = {}, Uargs(::) = {},
Uargs(insert) = {}, Uargs(insert#1) = {}, Uargs(tuple#2) = {},
Uargs(insert#2) = {}, Uargs(insert#3) = {}, Uargs(insert#4) = {},
Uargs(split) = {}, Uargs(split#1) = {}, Uargs(#and) = {},
Uargs(#neg) = {}, Uargs(#pos) = {}, Uargs(#s) = {},
Uargs(#equal^#) = {}, Uargs(#eq^#) = {}, Uargs(#greater^#) = {},
Uargs(#ckgt^#) = {}, Uargs(#compare^#) = {}, Uargs(append^#) = {},
Uargs(append#1^#) = {}, Uargs(insert^#) = {},
Uargs(insert#1^#) = {}, Uargs(insert#2^#) = {},
Uargs(insert#3^#) = {}, Uargs(insert#4^#) = {},
Uargs(quicksort^#) = {}, Uargs(quicksort#1^#) = {},
Uargs(quicksort#2^#) = {}, Uargs(splitqs^#) = {},
Uargs(splitqs#1^#) = {}, Uargs(sortAll^#) = {},
Uargs(sortAll#1^#) = {}, Uargs(sortAll#2^#) = {},
Uargs(split^#) = {}, Uargs(split#1^#) = {},
Uargs(splitAndSort^#) = {}, Uargs(splitqs#2^#) = {},
Uargs(splitqs#3^#) = {}, Uargs(#and^#) = {}
TcT has computed following constructor-based matrix interpretation
satisfying not(EDA).
[#equal](x1, x2) = [0]
[#eq](x1, x2) = [0]
[::](x1, x2) = [1] x1 + [1] x2 + [1]
[nil] = [2]
[insert](x1, x2) = [1] x2 + [2]
[insert#1](x1, x2, x3) = [1] x2 + [2]
[tuple#2](x1, x2) = [0]
[insert#2](x1, x2, x3, x4) = [1] x1 + [2]
[insert#3](x1, x2, x3, x4, x5) = [1] x3 + [3]
[insert#4](x1, x2, x3, x4, x5, x6) = [1] x3 + [3]
[#false] = [0]
[#true] = [0]
[split](x1) = [3] x1 + [1]
[split#1](x1) = [3] x1 + [1]
[#and](x1, x2) = [0]
[#EQ] = [0]
[#GT] = [0]
[#LT] = [0]
[#0] = [0]
[#neg](x1) = [1] x1 + [0]
[#pos](x1) = [1] x1 + [0]
[#s](x1) = [1] x1 + [0]
[#equal^#](x1, x2) = [0]
[#eq^#](x1, x2) = [0]
[#greater^#](x1, x2) = [0]
[#ckgt^#](x1) = [0]
[#compare^#](x1, x2) = [0]
[append^#](x1, x2) = [0]
[append#1^#](x1, x2) = [0]
[insert^#](x1, x2) = [1] x2 + [0]
[insert#1^#](x1, x2, x3) = [1] x2 + [0]
[insert#2^#](x1, x2, x3, x4) = [1] x1 + [0]
[insert#3^#](x1, x2, x3, x4, x5) = [1] x3 + [0]
[insert#4^#](x1, x2, x3, x4, x5, x6) = [1] x3 + [0]
[quicksort^#](x1) = [0]
[quicksort#1^#](x1) = [0]
[quicksort#2^#](x1, x2) = [0]
[splitqs^#](x1, x2) = [0]
[splitqs#1^#](x1, x2) = [0]
[sortAll^#](x1) = [0]
[sortAll#1^#](x1) = [0]
[sortAll#2^#](x1, x2) = [0]
[split^#](x1) = [3] x1 + [0]
[split#1^#](x1) = [3] x1 + [0]
[splitAndSort^#](x1) = [3] x1 + [3]
[splitqs#2^#](x1, x2, x3) = [0]
[splitqs#3^#](x1, x2, x3, x4) = [0]
[#and^#](x1, x2) = [0]
This order satisfies following ordering constraints
[#equal(@x, @y)] = [0]
>= [0]
= [#eq(@x, @y)]
[#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [0]
>= [0]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(::(@x_1, @x_2), nil())] = [0]
>= [0]
= [#false()]
[#eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2))] = [0]
>= [0]
= [#false()]
[#eq(nil(), ::(@y_1, @y_2))] = [0]
>= [0]
= [#false()]
[#eq(nil(), nil())] = [0]
>= [0]
= [#true()]
[#eq(nil(), tuple#2(@y_1, @y_2))] = [0]
>= [0]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2))] = [0]
>= [0]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), nil())] = [0]
>= [0]
= [#false()]
[#eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2))] = [0]
>= [0]
= [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]
[#eq(#0(), #0())] = [0]
>= [0]
= [#true()]
[#eq(#0(), #neg(@y))] = [0]
>= [0]
= [#false()]
[#eq(#0(), #pos(@y))] = [0]
>= [0]
= [#false()]
[#eq(#0(), #s(@y))] = [0]
>= [0]
= [#false()]
[#eq(#neg(@x), #0())] = [0]
>= [0]
= [#false()]
[#eq(#neg(@x), #neg(@y))] = [0]
>= [0]
= [#eq(@x, @y)]
[#eq(#neg(@x), #pos(@y))] = [0]
>= [0]
= [#false()]
[#eq(#pos(@x), #0())] = [0]
>= [0]
= [#false()]
[#eq(#pos(@x), #neg(@y))] = [0]
>= [0]
= [#false()]
[#eq(#pos(@x), #pos(@y))] = [0]
>= [0]
= [#eq(@x, @y)]
[#eq(#s(@x), #0())] = [0]
>= [0]
= [#false()]
[#eq(#s(@x), #s(@y))] = [0]
>= [0]
= [#eq(@x, @y)]
[insert(@x, @l)] = [1] @l + [2]
>= [1] @l + [2]
= [insert#1(@x, @l, @x)]
[insert#1(tuple#2(@valX, @keyX), @l, @x)] = [1] @l + [2]
>= [1] @l + [2]
= [insert#2(@l, @keyX, @valX, @x)]
[insert#2(::(@l1, @ls), @keyX, @valX, @x)] = [1] @l1 + [1] @ls + [3]
>= [1] @ls + [3]
= [insert#3(@l1, @keyX, @ls, @valX, @x)]
[insert#2(nil(), @keyX, @valX, @x)] = [4]
> [3]
= [::(tuple#2(::(@valX, nil()), @keyX), nil())]
[insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x)] = [1] @ls + [3]
>= [1] @ls + [3]
= [insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)]
[insert#4(#false(), @key1, @ls, @valX, @vals1, @x)] = [1] @ls + [3]
>= [1] @ls + [3]
= [::(tuple#2(@vals1, @key1), insert(@x, @ls))]
[insert#4(#true(), @key1, @ls, @valX, @vals1, @x)] = [1] @ls + [3]
> [1] @ls + [1]
= [::(tuple#2(::(@valX, @vals1), @key1), @ls)]
[split(@l)] = [3] @l + [1]
>= [3] @l + [1]
= [split#1(@l)]
[split#1(::(@x, @xs))] = [3] @x + [3] @xs + [4]
> [3] @xs + [3]
= [insert(@x, split(@xs))]
[split#1(nil())] = [7]
> [2]
= [nil()]
[#and(#false(), #false())] = [0]
>= [0]
= [#false()]
[#and(#false(), #true())] = [0]
>= [0]
= [#false()]
[#and(#true(), #false())] = [0]
>= [0]
= [#false()]
[#and(#true(), #true())] = [0]
>= [0]
= [#true()]
[insert^#(@x, @l)] = [1] @l + [0]
>= [1] @l + [0]
= [insert#1^#(@x, @l, @x)]
[insert#1^#(tuple#2(@valX, @keyX), @l, @x)] = [1] @l + [0]
>= [1] @l + [0]
= [insert#2^#(@l, @keyX, @valX, @x)]
[insert#2^#(::(@l1, @ls), @keyX, @valX, @x)] = [1] @l1 + [1] @ls + [1]
> [1] @ls + [0]
= [insert#3^#(@l1, @keyX, @ls, @valX, @x)]
[insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x)] = [1] @ls + [0]
>= [1] @ls + [0]
= [insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)]
[insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x)] = [1] @ls + [0]
>= [1] @ls + [0]
= [insert^#(@x, @ls)]
[split^#(@l)] = [3] @l + [0]
>= [3] @l + [0]
= [split#1^#(@l)]
[split#1^#(::(@x, @xs))] = [3] @x + [3] @xs + [3]
> [3] @xs + [1]
= [insert^#(@x, split(@xs))]
[split#1^#(::(@x, @xs))] = [3] @x + [3] @xs + [3]
> [3] @xs + [0]
= [split^#(@xs)]
[splitAndSort^#(@l)] = [3] @l + [3]
> [3] @l + [0]
= [split^#(@l)]
Processor 'matrix interpretation of dimension 1' induces the
complexity certificate YES(?,O(n^1)) on application of rules
{3,7,8,9}. Here rules are labeled according to the (estimated)
dependency graph
1: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
-->_1 insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x) :2
2: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
-->_1 insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x) :3
3: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
-->_1 insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x) :4
4: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
-->_1 insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls) :5
5: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
6: split^#(@l) -> split#1^#(@l)
-->_1 split#1^#(::(@x, @xs)) -> split^#(@xs) :8
-->_1 split#1^#(::(@x, @xs)) -> insert^#(@x, split(@xs)) :7
7: split#1^#(::(@x, @xs)) -> insert^#(@x, split(@xs))
-->_1 insert^#(@x, @l) -> insert#1^#(@x, @l, @x) :1
8: split#1^#(::(@x, @xs)) -> split^#(@xs)
-->_1 split^#(@l) -> split#1^#(@l) :6
9: splitAndSort^#(@l) -> split^#(@l)
-->_1 split^#(@l) -> split#1^#(@l) :6
- The rules {3,7,8,9} have known complexity. These cover all
predecessors of {4,6}, their complexity is equally bounded.
- The rules {3,4,6,7,8,9} have known complexity. These cover all
predecessors of {5}, their complexity is equally bounded.
- The rules {3,4,5,6,7,8,9} have known complexity. These cover all
predecessors of {1}, their complexity is equally bounded.
- The rules {1,3,4,5,6,7,8,9} have known complexity. These cover
all predecessors of {2}, their complexity is equally bounded.
Overall, we obtain that the number of applications of rules
{1,2,3,4,5,6,7,8,9} is given by YES(?,O(n^1)).
We apply the transformation 'removetails' on the sub-problem:
Weak DPs:
{ insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, split^#(@l) -> split#1^#(@l)
, split#1^#(::(@x, @xs)) -> insert^#(@x, split(@xs))
, split#1^#(::(@x, @xs)) -> split^#(@xs)
, splitAndSort^#(@l) -> split^#(@l) }
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
We consider the the dependency graph
->1:{9} Weak SCC
|
`->2:{6,8} Weak SCC
|
`->3:{7} Weak SCC
|
`->4:{1,5,4,3,2} Weak SCC
Here dependency-pairs are as follows:
Weak DPs:
{ 1: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, 2: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x)
, 3: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, 4: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, 5: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, 6: split^#(@l) -> split#1^#(@l)
, 7: split#1^#(::(@x, @xs)) -> insert^#(@x, split(@xs))
, 8: split#1^#(::(@x, @xs)) -> split^#(@xs)
, 9: splitAndSort^#(@l) -> split^#(@l) }
The following rules are part of trailing weak paths, and thus they
can be removed:
{ 9: splitAndSort^#(@l) -> split^#(@l)
, 6: split^#(@l) -> split#1^#(@l)
, 8: split#1^#(::(@x, @xs)) -> split^#(@xs)
, 7: split#1^#(::(@x, @xs)) -> insert^#(@x, split(@xs))
, 1: insert^#(@x, @l) -> insert#1^#(@x, @l, @x)
, 5: insert#4^#(#false(), @key1, @ls, @valX, @vals1, @x) ->
insert^#(@x, @ls)
, 4: insert#3^#(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4^#(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, 3: insert#2^#(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3^#(@l1, @keyX, @ls, @valX, @x)
, 2: insert#1^#(tuple#2(@valX, @keyX), @l, @x) ->
insert#2^#(@l, @keyX, @valX, @x) }
We apply the transformation 'usablerules' on the sub-problem:
Weak Trs:
{ #equal(@x, @y) -> #eq(@x, @y)
, #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(::(@x_1, @x_2), nil()) -> #false()
, #eq(::(@x_1, @x_2), tuple#2(@y_1, @y_2)) -> #false()
, #eq(nil(), ::(@y_1, @y_2)) -> #false()
, #eq(nil(), nil()) -> #true()
, #eq(nil(), tuple#2(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), ::(@y_1, @y_2)) -> #false()
, #eq(tuple#2(@x_1, @x_2), nil()) -> #false()
, #eq(tuple#2(@x_1, @x_2), tuple#2(@y_1, @y_2)) ->
#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
, #eq(#0(), #0()) -> #true()
, #eq(#0(), #neg(@y)) -> #false()
, #eq(#0(), #pos(@y)) -> #false()
, #eq(#0(), #s(@y)) -> #false()
, #eq(#neg(@x), #0()) -> #false()
, #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
, #eq(#neg(@x), #pos(@y)) -> #false()
, #eq(#pos(@x), #0()) -> #false()
, #eq(#pos(@x), #neg(@y)) -> #false()
, #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
, #eq(#s(@x), #0()) -> #false()
, #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
, insert(@x, @l) -> insert#1(@x, @l, @x)
, insert#1(tuple#2(@valX, @keyX), @l, @x) ->
insert#2(@l, @keyX, @valX, @x)
, insert#2(::(@l1, @ls), @keyX, @valX, @x) ->
insert#3(@l1, @keyX, @ls, @valX, @x)
, insert#2(nil(), @keyX, @valX, @x) ->
::(tuple#2(::(@valX, nil()), @keyX), nil())
, insert#3(tuple#2(@vals1, @key1), @keyX, @ls, @valX, @x) ->
insert#4(#equal(@key1, @keyX), @key1, @ls, @valX, @vals1, @x)
, insert#4(#false(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(@vals1, @key1), insert(@x, @ls))
, insert#4(#true(), @key1, @ls, @valX, @vals1, @x) ->
::(tuple#2(::(@valX, @vals1), @key1), @ls)
, split(@l) -> split#1(@l)
, split#1(::(@x, @xs)) -> insert(@x, split(@xs))
, split#1(nil()) -> nil()
, #and(#false(), #false()) -> #false()
, #and(#false(), #true()) -> #false()
, #and(#true(), #false()) -> #false()
, #and(#true(), #true()) -> #true() }
StartTerms: basic terms
Strategy: innermost
No rule is usable.
We apply the transformation 'trivial' on the sub-problem:
Rules: Empty
StartTerms: basic terms
Strategy: innermost
We consider the dependency graph
empty
All SCCs are trivial and dependency pairs can be removed.
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
Arrrr..