* Step 1: Sum WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict TRS:
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1
,#s/1,#true/0,::/2,nil/0,tuple#2/2}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt,#compare,#less,merge,merge#1,merge#2,merge#3
,mergesort,mergesort#1,mergesort#2,mergesort#3,msplit,msplit#1,msplit#2,msplit#3} and constructors {#0,#EQ
,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
Sum {left = someStrategy, right = someStrategy}
+ Details:
()
* Step 2: DependencyPairs WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict TRS:
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1
,#s/1,#true/0,::/2,nil/0,tuple#2/2}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt,#compare,#less,merge,merge#1,merge#2,merge#3
,mergesort,mergesort#1,mergesort#2,mergesort#3,msplit,msplit#1,msplit#2,msplit#3} and constructors {#0,#EQ
,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
DependencyPairs {dpKind_ = DT}
+ Details:
We add the following dependency tuples:
Strict DPs
#less#(@x,@y) -> c_1(#cklt#(#compare(@x,@y)),#compare#(@x,@y))
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#1#(nil(),@l2) -> c_4()
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys),#less#(@x,@y))
merge#2#(nil(),@x,@xs) -> c_6()
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#1#(nil()) -> c_11()
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
mergesort#2#(nil(),@x1) -> c_13()
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
msplit#(@l) -> c_15(msplit#1#(@l))
msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
msplit#1#(nil()) -> c_17()
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#3#(msplit(@xs'),@x1,@x2),msplit#(@xs'))
msplit#2#(nil(),@x1) -> c_19()
msplit#3#(tuple#2(@l1,@l2),@x1,@x2) -> c_20()
Weak DPs
#cklt#(#EQ()) -> c_21()
#cklt#(#GT()) -> c_22()
#cklt#(#LT()) -> c_23()
#compare#(#0(),#0()) -> c_24()
#compare#(#0(),#neg(@y)) -> c_25()
#compare#(#0(),#pos(@y)) -> c_26()
#compare#(#0(),#s(@y)) -> c_27()
#compare#(#neg(@x),#0()) -> c_28()
#compare#(#neg(@x),#neg(@y)) -> c_29(#compare#(@y,@x))
#compare#(#neg(@x),#pos(@y)) -> c_30()
#compare#(#pos(@x),#0()) -> c_31()
#compare#(#pos(@x),#neg(@y)) -> c_32()
#compare#(#pos(@x),#pos(@y)) -> c_33(#compare#(@x,@y))
#compare#(#s(@x),#0()) -> c_34()
#compare#(#s(@x),#s(@y)) -> c_35(#compare#(@x,@y))
and mark the set of starting terms.
* Step 3: PredecessorEstimation WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
#less#(@x,@y) -> c_1(#cklt#(#compare(@x,@y)),#compare#(@x,@y))
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#1#(nil(),@l2) -> c_4()
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys),#less#(@x,@y))
merge#2#(nil(),@x,@xs) -> c_6()
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#1#(nil()) -> c_11()
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
mergesort#2#(nil(),@x1) -> c_13()
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
msplit#(@l) -> c_15(msplit#1#(@l))
msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
msplit#1#(nil()) -> c_17()
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#3#(msplit(@xs'),@x1,@x2),msplit#(@xs'))
msplit#2#(nil(),@x1) -> c_19()
msplit#3#(tuple#2(@l1,@l2),@x1,@x2) -> c_20()
- Weak DPs:
#cklt#(#EQ()) -> c_21()
#cklt#(#GT()) -> c_22()
#cklt#(#LT()) -> c_23()
#compare#(#0(),#0()) -> c_24()
#compare#(#0(),#neg(@y)) -> c_25()
#compare#(#0(),#pos(@y)) -> c_26()
#compare#(#0(),#s(@y)) -> c_27()
#compare#(#neg(@x),#0()) -> c_28()
#compare#(#neg(@x),#neg(@y)) -> c_29(#compare#(@y,@x))
#compare#(#neg(@x),#pos(@y)) -> c_30()
#compare#(#pos(@x),#0()) -> c_31()
#compare#(#pos(@x),#neg(@y)) -> c_32()
#compare#(#pos(@x),#pos(@y)) -> c_33(#compare#(@x,@y))
#compare#(#s(@x),#0()) -> c_34()
#compare#(#s(@x),#s(@y)) -> c_35(#compare#(@x,@y))
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/2,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
PredecessorEstimation {onSelection = all simple predecessor estimation selector}
+ Details:
We estimate the number of application of
{1,4,6,11,13,17,19,20}
by application of
Pre({1,4,6,11,13,17,19,20}) = {2,3,5,9,10,15,16,18}.
Here rules are labelled as follows:
1: #less#(@x,@y) -> c_1(#cklt#(#compare(@x,@y)),#compare#(@x,@y))
2: merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
3: merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
4: merge#1#(nil(),@l2) -> c_4()
5: merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys),#less#(@x,@y))
6: merge#2#(nil(),@x,@xs) -> c_6()
7: merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
8: merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
9: mergesort#(@l) -> c_9(mergesort#1#(@l))
10: mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
11: mergesort#1#(nil()) -> c_11()
12: mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
13: mergesort#2#(nil(),@x1) -> c_13()
14: mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
15: msplit#(@l) -> c_15(msplit#1#(@l))
16: msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
17: msplit#1#(nil()) -> c_17()
18: msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#3#(msplit(@xs'),@x1,@x2),msplit#(@xs'))
19: msplit#2#(nil(),@x1) -> c_19()
20: msplit#3#(tuple#2(@l1,@l2),@x1,@x2) -> c_20()
21: #cklt#(#EQ()) -> c_21()
22: #cklt#(#GT()) -> c_22()
23: #cklt#(#LT()) -> c_23()
24: #compare#(#0(),#0()) -> c_24()
25: #compare#(#0(),#neg(@y)) -> c_25()
26: #compare#(#0(),#pos(@y)) -> c_26()
27: #compare#(#0(),#s(@y)) -> c_27()
28: #compare#(#neg(@x),#0()) -> c_28()
29: #compare#(#neg(@x),#neg(@y)) -> c_29(#compare#(@y,@x))
30: #compare#(#neg(@x),#pos(@y)) -> c_30()
31: #compare#(#pos(@x),#0()) -> c_31()
32: #compare#(#pos(@x),#neg(@y)) -> c_32()
33: #compare#(#pos(@x),#pos(@y)) -> c_33(#compare#(@x,@y))
34: #compare#(#s(@x),#0()) -> c_34()
35: #compare#(#s(@x),#s(@y)) -> c_35(#compare#(@x,@y))
* Step 4: RemoveWeakSuffixes WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys),#less#(@x,@y))
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
msplit#(@l) -> c_15(msplit#1#(@l))
msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#3#(msplit(@xs'),@x1,@x2),msplit#(@xs'))
- Weak DPs:
#cklt#(#EQ()) -> c_21()
#cklt#(#GT()) -> c_22()
#cklt#(#LT()) -> c_23()
#compare#(#0(),#0()) -> c_24()
#compare#(#0(),#neg(@y)) -> c_25()
#compare#(#0(),#pos(@y)) -> c_26()
#compare#(#0(),#s(@y)) -> c_27()
#compare#(#neg(@x),#0()) -> c_28()
#compare#(#neg(@x),#neg(@y)) -> c_29(#compare#(@y,@x))
#compare#(#neg(@x),#pos(@y)) -> c_30()
#compare#(#pos(@x),#0()) -> c_31()
#compare#(#pos(@x),#neg(@y)) -> c_32()
#compare#(#pos(@x),#pos(@y)) -> c_33(#compare#(@x,@y))
#compare#(#s(@x),#0()) -> c_34()
#compare#(#s(@x),#s(@y)) -> c_35(#compare#(@x,@y))
#less#(@x,@y) -> c_1(#cklt#(#compare(@x,@y)),#compare#(@x,@y))
merge#1#(nil(),@l2) -> c_4()
merge#2#(nil(),@x,@xs) -> c_6()
mergesort#1#(nil()) -> c_11()
mergesort#2#(nil(),@x1) -> c_13()
msplit#1#(nil()) -> c_17()
msplit#2#(nil(),@x1) -> c_19()
msplit#3#(tuple#2(@l1,@l2),@x1,@x2) -> c_20()
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/2,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
RemoveWeakSuffixes
+ Details:
Consider the dependency graph
1:S:merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
-->_1 merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs)):2
-->_1 merge#1#(nil(),@l2) -> c_4():29
2:S:merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
-->_1 merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys),#less#(@x,@y)):3
-->_1 merge#2#(nil(),@x,@xs) -> c_6():30
3:S:merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys),#less#(@x,@y))
-->_2 #less#(@x,@y) -> c_1(#cklt#(#compare(@x,@y)),#compare#(@x,@y)):28
-->_1 merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys))):5
-->_1 merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys)):4
4:S:merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
-->_1 merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2)):1
5:S:merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
-->_1 merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2)):1
6:S:mergesort#(@l) -> c_9(mergesort#1#(@l))
-->_1 mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1)):7
-->_1 mergesort#1#(nil()) -> c_11():31
7:S:mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
-->_1 mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs')))):8
-->_1 mergesort#2#(nil(),@x1) -> c_13():32
8:S:mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
-->_2 msplit#(@l) -> c_15(msplit#1#(@l)):10
-->_1 mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2)):9
9:S:mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
-->_3 mergesort#(@l) -> c_9(mergesort#1#(@l)):6
-->_2 mergesort#(@l) -> c_9(mergesort#1#(@l)):6
-->_1 merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2)):1
10:S:msplit#(@l) -> c_15(msplit#1#(@l))
-->_1 msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1)):11
-->_1 msplit#1#(nil()) -> c_17():33
11:S:msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
-->_1 msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#3#(msplit(@xs'),@x1,@x2),msplit#(@xs')):12
-->_1 msplit#2#(nil(),@x1) -> c_19():34
12:S:msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#3#(msplit(@xs'),@x1,@x2),msplit#(@xs'))
-->_1 msplit#3#(tuple#2(@l1,@l2),@x1,@x2) -> c_20():35
-->_2 msplit#(@l) -> c_15(msplit#1#(@l)):10
13:W:#cklt#(#EQ()) -> c_21()
14:W:#cklt#(#GT()) -> c_22()
15:W:#cklt#(#LT()) -> c_23()
16:W:#compare#(#0(),#0()) -> c_24()
17:W:#compare#(#0(),#neg(@y)) -> c_25()
18:W:#compare#(#0(),#pos(@y)) -> c_26()
19:W:#compare#(#0(),#s(@y)) -> c_27()
20:W:#compare#(#neg(@x),#0()) -> c_28()
21:W:#compare#(#neg(@x),#neg(@y)) -> c_29(#compare#(@y,@x))
-->_1 #compare#(#s(@x),#s(@y)) -> c_35(#compare#(@x,@y)):27
-->_1 #compare#(#pos(@x),#pos(@y)) -> c_33(#compare#(@x,@y)):25
-->_1 #compare#(#s(@x),#0()) -> c_34():26
-->_1 #compare#(#pos(@x),#neg(@y)) -> c_32():24
-->_1 #compare#(#pos(@x),#0()) -> c_31():23
-->_1 #compare#(#neg(@x),#pos(@y)) -> c_30():22
-->_1 #compare#(#neg(@x),#neg(@y)) -> c_29(#compare#(@y,@x)):21
-->_1 #compare#(#neg(@x),#0()) -> c_28():20
-->_1 #compare#(#0(),#s(@y)) -> c_27():19
-->_1 #compare#(#0(),#pos(@y)) -> c_26():18
-->_1 #compare#(#0(),#neg(@y)) -> c_25():17
-->_1 #compare#(#0(),#0()) -> c_24():16
22:W:#compare#(#neg(@x),#pos(@y)) -> c_30()
23:W:#compare#(#pos(@x),#0()) -> c_31()
24:W:#compare#(#pos(@x),#neg(@y)) -> c_32()
25:W:#compare#(#pos(@x),#pos(@y)) -> c_33(#compare#(@x,@y))
-->_1 #compare#(#s(@x),#s(@y)) -> c_35(#compare#(@x,@y)):27
-->_1 #compare#(#s(@x),#0()) -> c_34():26
-->_1 #compare#(#pos(@x),#pos(@y)) -> c_33(#compare#(@x,@y)):25
-->_1 #compare#(#pos(@x),#neg(@y)) -> c_32():24
-->_1 #compare#(#pos(@x),#0()) -> c_31():23
-->_1 #compare#(#neg(@x),#pos(@y)) -> c_30():22
-->_1 #compare#(#neg(@x),#neg(@y)) -> c_29(#compare#(@y,@x)):21
-->_1 #compare#(#neg(@x),#0()) -> c_28():20
-->_1 #compare#(#0(),#s(@y)) -> c_27():19
-->_1 #compare#(#0(),#pos(@y)) -> c_26():18
-->_1 #compare#(#0(),#neg(@y)) -> c_25():17
-->_1 #compare#(#0(),#0()) -> c_24():16
26:W:#compare#(#s(@x),#0()) -> c_34()
27:W:#compare#(#s(@x),#s(@y)) -> c_35(#compare#(@x,@y))
-->_1 #compare#(#s(@x),#s(@y)) -> c_35(#compare#(@x,@y)):27
-->_1 #compare#(#s(@x),#0()) -> c_34():26
-->_1 #compare#(#pos(@x),#pos(@y)) -> c_33(#compare#(@x,@y)):25
-->_1 #compare#(#pos(@x),#neg(@y)) -> c_32():24
-->_1 #compare#(#pos(@x),#0()) -> c_31():23
-->_1 #compare#(#neg(@x),#pos(@y)) -> c_30():22
-->_1 #compare#(#neg(@x),#neg(@y)) -> c_29(#compare#(@y,@x)):21
-->_1 #compare#(#neg(@x),#0()) -> c_28():20
-->_1 #compare#(#0(),#s(@y)) -> c_27():19
-->_1 #compare#(#0(),#pos(@y)) -> c_26():18
-->_1 #compare#(#0(),#neg(@y)) -> c_25():17
-->_1 #compare#(#0(),#0()) -> c_24():16
28:W:#less#(@x,@y) -> c_1(#cklt#(#compare(@x,@y)),#compare#(@x,@y))
-->_2 #compare#(#s(@x),#s(@y)) -> c_35(#compare#(@x,@y)):27
-->_2 #compare#(#s(@x),#0()) -> c_34():26
-->_2 #compare#(#pos(@x),#pos(@y)) -> c_33(#compare#(@x,@y)):25
-->_2 #compare#(#pos(@x),#neg(@y)) -> c_32():24
-->_2 #compare#(#pos(@x),#0()) -> c_31():23
-->_2 #compare#(#neg(@x),#pos(@y)) -> c_30():22
-->_2 #compare#(#neg(@x),#neg(@y)) -> c_29(#compare#(@y,@x)):21
-->_2 #compare#(#neg(@x),#0()) -> c_28():20
-->_2 #compare#(#0(),#s(@y)) -> c_27():19
-->_2 #compare#(#0(),#pos(@y)) -> c_26():18
-->_2 #compare#(#0(),#neg(@y)) -> c_25():17
-->_2 #compare#(#0(),#0()) -> c_24():16
-->_1 #cklt#(#LT()) -> c_23():15
-->_1 #cklt#(#GT()) -> c_22():14
-->_1 #cklt#(#EQ()) -> c_21():13
29:W:merge#1#(nil(),@l2) -> c_4()
30:W:merge#2#(nil(),@x,@xs) -> c_6()
31:W:mergesort#1#(nil()) -> c_11()
32:W:mergesort#2#(nil(),@x1) -> c_13()
33:W:msplit#1#(nil()) -> c_17()
34:W:msplit#2#(nil(),@x1) -> c_19()
35:W:msplit#3#(tuple#2(@l1,@l2),@x1,@x2) -> c_20()
The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
31: mergesort#1#(nil()) -> c_11()
32: mergesort#2#(nil(),@x1) -> c_13()
33: msplit#1#(nil()) -> c_17()
34: msplit#2#(nil(),@x1) -> c_19()
35: msplit#3#(tuple#2(@l1,@l2),@x1,@x2) -> c_20()
29: merge#1#(nil(),@l2) -> c_4()
30: merge#2#(nil(),@x,@xs) -> c_6()
28: #less#(@x,@y) -> c_1(#cklt#(#compare(@x,@y)),#compare#(@x,@y))
13: #cklt#(#EQ()) -> c_21()
14: #cklt#(#GT()) -> c_22()
15: #cklt#(#LT()) -> c_23()
27: #compare#(#s(@x),#s(@y)) -> c_35(#compare#(@x,@y))
25: #compare#(#pos(@x),#pos(@y)) -> c_33(#compare#(@x,@y))
21: #compare#(#neg(@x),#neg(@y)) -> c_29(#compare#(@y,@x))
16: #compare#(#0(),#0()) -> c_24()
17: #compare#(#0(),#neg(@y)) -> c_25()
18: #compare#(#0(),#pos(@y)) -> c_26()
19: #compare#(#0(),#s(@y)) -> c_27()
20: #compare#(#neg(@x),#0()) -> c_28()
22: #compare#(#neg(@x),#pos(@y)) -> c_30()
23: #compare#(#pos(@x),#0()) -> c_31()
24: #compare#(#pos(@x),#neg(@y)) -> c_32()
26: #compare#(#s(@x),#0()) -> c_34()
* Step 5: SimplifyRHS WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys),#less#(@x,@y))
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
msplit#(@l) -> c_15(msplit#1#(@l))
msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#3#(msplit(@xs'),@x1,@x2),msplit#(@xs'))
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/2,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/2,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
SimplifyRHS
+ Details:
Consider the dependency graph
1:S:merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
-->_1 merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs)):2
2:S:merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
-->_1 merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys),#less#(@x,@y)):3
3:S:merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys),#less#(@x,@y))
-->_1 merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys))):5
-->_1 merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys)):4
4:S:merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
-->_1 merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2)):1
5:S:merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
-->_1 merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2)):1
6:S:mergesort#(@l) -> c_9(mergesort#1#(@l))
-->_1 mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1)):7
7:S:mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
-->_1 mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs')))):8
8:S:mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
-->_2 msplit#(@l) -> c_15(msplit#1#(@l)):10
-->_1 mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2)):9
9:S:mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
-->_3 mergesort#(@l) -> c_9(mergesort#1#(@l)):6
-->_2 mergesort#(@l) -> c_9(mergesort#1#(@l)):6
-->_1 merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2)):1
10:S:msplit#(@l) -> c_15(msplit#1#(@l))
-->_1 msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1)):11
11:S:msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
-->_1 msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#3#(msplit(@xs'),@x1,@x2),msplit#(@xs')):12
12:S:msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#3#(msplit(@xs'),@x1,@x2),msplit#(@xs'))
-->_2 msplit#(@l) -> c_15(msplit#1#(@l)):10
Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified:
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
* Step 6: Decompose WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
msplit#(@l) -> c_15(msplit#1#(@l))
msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
Decompose {onSelection = all cycle independent sub-graph, withBound = RelativeAdd}
+ Details:
We analyse the complexity of following sub-problems (R) and (S).
Problem (S) is obtained from the input problem by shifting strict rules from (R) into the weak component.
Problem (R)
- Strict DPs:
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
- Weak DPs:
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
msplit#(@l) -> c_15(msplit#1#(@l))
msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0
,tuple#2/2,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/3,c_15/1
,c_16/1,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0
,c_31/0,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#
,merge#3#,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
Problem (S)
- Strict DPs:
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
msplit#(@l) -> c_15(msplit#1#(@l))
msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
- Weak DPs:
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0
,tuple#2/2,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/3,c_15/1
,c_16/1,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0
,c_31/0,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#
,merge#3#,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
** Step 6.a:1: RemoveWeakSuffixes WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
- Weak DPs:
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
msplit#(@l) -> c_15(msplit#1#(@l))
msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
RemoveWeakSuffixes
+ Details:
Consider the dependency graph
1:S:merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
-->_1 merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs)):2
2:S:merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
-->_1 merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys)):3
3:S:merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
-->_1 merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys))):5
-->_1 merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys)):4
4:S:merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
-->_1 merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2)):1
5:S:merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
-->_1 merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2)):1
6:W:mergesort#(@l) -> c_9(mergesort#1#(@l))
-->_1 mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1)):7
7:W:mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
-->_1 mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs')))):8
8:W:mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
-->_2 msplit#(@l) -> c_15(msplit#1#(@l)):10
-->_1 mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2)):9
9:W:mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
-->_1 merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2)):1
-->_3 mergesort#(@l) -> c_9(mergesort#1#(@l)):6
-->_2 mergesort#(@l) -> c_9(mergesort#1#(@l)):6
10:W:msplit#(@l) -> c_15(msplit#1#(@l))
-->_1 msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1)):11
11:W:msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
-->_1 msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs')):12
12:W:msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
-->_1 msplit#(@l) -> c_15(msplit#1#(@l)):10
The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
10: msplit#(@l) -> c_15(msplit#1#(@l))
12: msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
11: msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
** Step 6.a:2: SimplifyRHS WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
- Weak DPs:
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
SimplifyRHS
+ Details:
Consider the dependency graph
1:S:merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
-->_1 merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs)):2
2:S:merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
-->_1 merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys)):3
3:S:merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
-->_1 merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys))):5
-->_1 merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys)):4
4:S:merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
-->_1 merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2)):1
5:S:merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
-->_1 merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2)):1
6:W:mergesort#(@l) -> c_9(mergesort#1#(@l))
-->_1 mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1)):7
7:W:mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
-->_1 mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs')))):8
8:W:mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
-->_1 mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2)):9
9:W:mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
-->_1 merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2)):1
-->_3 mergesort#(@l) -> c_9(mergesort#1#(@l)):6
-->_2 mergesort#(@l) -> c_9(mergesort#1#(@l)):6
Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified:
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs')))))
** Step 6.a:3: DecomposeDG WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
- Weak DPs:
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs')))))
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/1,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
DecomposeDG {onSelection = all below first cut in WDG, onUpper = Just someStrategy, onLower = Nothing}
+ Details:
We decompose the input problem according to the dependency graph into the upper component
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs')))))
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
and a lower component
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
Further, following extension rules are added to the lower component.
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> merge#(mergesort(@l1),mergesort(@l2))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
*** Step 6.a:3.a:1: PredecessorEstimationCP WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
- Weak DPs:
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs')))))
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/1,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 3, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}}
+ Details:
We first use the processor NaturalMI {miDimension = 3, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
1: mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
Consider the set of all dependency pairs
1: mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
2: mergesort#(@l) -> c_9(mergesort#1#(@l))
3: mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
4: mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs')))))
Processor NaturalMI {miDimension = 3, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}induces the complexity certificateTIME (?,O(n^1))
SPACE(?,?)on application of the dependency pairs
{1}
These cover all (indirect) predecessors of dependency pairs
{1,2,3,4}
their number of applications is equally bounded.
The dependency pairs are shifted into the weak component.
**** Step 6.a:3.a:1.a:1: NaturalMI WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
- Weak DPs:
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs')))))
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/1,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
NaturalMI {miDimension = 3, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules}
+ Details:
We apply a matrix interpretation of kind constructor based matrix interpretation (containing no more than 1 non-zero interpretation-entries in the diagonal of the component-wise maxima):
The following argument positions are considered usable:
uargs(c_9) = {1},
uargs(c_10) = {1},
uargs(c_12) = {1},
uargs(c_14) = {1,2,3}
Following symbols are considered usable:
{msplit,msplit#1,msplit#2,msplit#3,#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#,mergesort#
,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#,msplit#3#}
TcT has computed the following interpretation:
p(#0) = [0]
[0]
[1]
p(#EQ) = [1]
[1]
[1]
p(#GT) = [1]
[0]
[0]
p(#LT) = [0]
[0]
[0]
p(#cklt) = [1 1 0] [0]
[1 0 1] x1 + [1]
[1 0 0] [1]
p(#compare) = [0 0 0] [0 1 0] [0]
[1 1 1] x1 + [0 0 1] x2 + [0]
[1 1 0] [1 0 0] [0]
p(#false) = [0]
[1]
[0]
p(#less) = [0 0 0] [1 0 0] [0]
[0 1 0] x1 + [0 0 1] x2 + [1]
[0 0 0] [1 1 1] [1]
p(#neg) = [0]
[1]
[1]
p(#pos) = [0]
[0]
[0]
p(#s) = [0 0 1] [1]
[0 0 1] x1 + [0]
[0 0 0] [1]
p(#true) = [0]
[1]
[0]
p(::) = [0 1 0] [0]
[0 1 1] x2 + [0]
[0 0 0] [1]
p(merge) = [0 0 0] [1 1 1] [0]
[0 0 0] x1 + [0 0 1] x2 + [0]
[0 0 1] [0 0 0] [0]
p(merge#1) = [0 0 0] [0]
[0 1 0] x1 + [0]
[0 0 0] [0]
p(merge#2) = [0 0 1] [0]
[0 0 0] x1 + [0]
[0 0 0] [0]
p(merge#3) = [0 0 0] [0 0 0] [1 1 0] [1]
[1 0 1] x1 + [0 0 0] x2 + [0 0 0] x4 + [1]
[0 1 1] [0 1 0] [0 0 0] [1]
p(mergesort) = [1 0 0] [0]
[0 1 0] x1 + [0]
[0 0 1] [0]
p(mergesort#1) = [0 0 1] [0]
[0 0 1] x1 + [1]
[0 0 0] [1]
p(mergesort#2) = [0 0 1] [0]
[0 1 1] x1 + [0]
[0 1 0] [0]
p(mergesort#3) = [0 0 0] [0]
[1 0 0] x1 + [0]
[0 0 1] [0]
p(msplit) = [1 0 0] [0]
[0 1 1] x1 + [0]
[0 0 0] [1]
p(msplit#1) = [1 0 0] [0]
[0 1 1] x1 + [0]
[0 0 0] [1]
p(msplit#2) = [0 1 0] [0]
[0 1 1] x1 + [1]
[0 0 0] [1]
p(msplit#3) = [0 1 0] [0]
[0 1 1] x1 + [1]
[0 0 0] [1]
p(nil) = [0]
[0]
[0]
p(tuple#2) = [0 1 0] [0 1 0] [0]
[0 1 1] x1 + [0 1 1] x2 + [0]
[0 0 0] [0 0 0] [1]
p(#cklt#) = [0]
[0]
[0]
p(#compare#) = [0]
[0]
[0]
p(#less#) = [0]
[0]
[0]
p(merge#) = [0]
[1]
[0]
p(merge#1#) = [0]
[0]
[0]
p(merge#2#) = [0]
[0]
[0]
p(merge#3#) = [0]
[0]
[0]
p(mergesort#) = [0 1 0] [0]
[1 0 0] x1 + [0]
[0 0 0] [0]
p(mergesort#1#) = [0 1 0] [0]
[0 0 1] x1 + [1]
[1 0 0] [0]
p(mergesort#2#) = [0 1 1] [0 0 0] [0]
[0 0 0] x1 + [1 0 1] x2 + [1]
[0 0 1] [1 0 1] [1]
p(mergesort#3#) = [1 0 1] [0]
[0 0 1] x1 + [1]
[0 0 0] [1]
p(msplit#) = [0]
[0]
[0]
p(msplit#1#) = [0]
[0]
[0]
p(msplit#2#) = [0]
[0]
[0]
p(msplit#3#) = [0]
[0]
[0]
p(c_1) = [0]
[0]
[0]
p(c_2) = [0]
[0]
[0]
p(c_3) = [0]
[0]
[0]
p(c_4) = [0]
[0]
[0]
p(c_5) = [0]
[0]
[0]
p(c_6) = [0]
[0]
[0]
p(c_7) = [0]
[0]
[0]
p(c_8) = [0]
[0]
[0]
p(c_9) = [1 0 0] [0]
[0 0 1] x1 + [0]
[0 0 0] [0]
p(c_10) = [1 0 0] [0]
[0 0 0] x1 + [0]
[0 0 0] [0]
p(c_11) = [0]
[0]
[0]
p(c_12) = [1 0 0] [0]
[0 0 0] x1 + [0]
[0 0 1] [0]
p(c_13) = [0]
[0]
[0]
p(c_14) = [1 0 0] [1 0 0] [1 0 0] [0]
[0 1 0] x1 + [0 0 0] x2 + [0 0 0] x3 + [1]
[0 1 0] [0 0 0] [0 0 0] [0]
p(c_15) = [0]
[0]
[0]
p(c_16) = [0]
[0]
[0]
p(c_17) = [0]
[0]
[0]
p(c_18) = [0]
[0]
[0]
p(c_19) = [0]
[0]
[0]
p(c_20) = [0]
[0]
[0]
p(c_21) = [0]
[0]
[0]
p(c_22) = [0]
[0]
[0]
p(c_23) = [0]
[0]
[0]
p(c_24) = [0]
[0]
[0]
p(c_25) = [0]
[0]
[0]
p(c_26) = [0]
[0]
[0]
p(c_27) = [0]
[0]
[0]
p(c_28) = [0]
[0]
[0]
p(c_29) = [0]
[0]
[0]
p(c_30) = [0]
[0]
[0]
p(c_31) = [0]
[0]
[0]
p(c_32) = [0]
[0]
[0]
p(c_33) = [0]
[0]
[0]
p(c_34) = [0]
[0]
[0]
p(c_35) = [0]
[0]
[0]
Following rules are strictly oriented:
mergesort#3#(tuple#2(@l1,@l2)) = [0 1 0] [0 1 0] [1]
[0 0 0] @l1 + [0 0 0] @l2 + [2]
[0 0 0] [0 0 0] [1]
> [0 1 0] [0 1 0] [0]
[0 0 0] @l1 + [0 0 0] @l2 + [2]
[0 0 0] [0 0 0] [1]
= c_14(merge#(mergesort(@l1),mergesort(@l2)),mergesort#(@l1),mergesort#(@l2))
Following rules are (at-least) weakly oriented:
mergesort#(@l) = [0 1 0] [0]
[1 0 0] @l + [0]
[0 0 0] [0]
>= [0 1 0] [0]
[1 0 0] @l + [0]
[0 0 0] [0]
= c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) = [0 1 1] [0]
[0 0 0] @xs + [2]
[0 1 0] [0]
>= [0 1 1] [0]
[0 0 0] @xs + [0]
[0 0 0] [0]
= c_10(mergesort#2#(@xs,@x1))
mergesort#2#(::(@x2,@xs'),@x1) = [0 0 0] [0 1 1] [1]
[1 0 1] @x1 + [0 0 0] @xs' + [1]
[1 0 1] [0 0 0] [2]
>= [0 1 1] [1]
[0 0 0] @xs' + [0]
[0 0 0] [1]
= c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs')))))
msplit(@l) = [1 0 0] [0]
[0 1 1] @l + [0]
[0 0 0] [1]
>= [1 0 0] [0]
[0 1 1] @l + [0]
[0 0 0] [1]
= msplit#1(@l)
msplit#1(::(@x1,@xs)) = [0 1 0] [0]
[0 1 1] @xs + [1]
[0 0 0] [1]
>= [0 1 0] [0]
[0 1 1] @xs + [1]
[0 0 0] [1]
= msplit#2(@xs,@x1)
msplit#1(nil()) = [0]
[0]
[1]
>= [0]
[0]
[1]
= tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) = [0 1 1] [0]
[0 1 1] @xs' + [2]
[0 0 0] [1]
>= [0 1 1] [0]
[0 1 1] @xs' + [2]
[0 0 0] [1]
= msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) = [0]
[1]
[1]
>= [0]
[1]
[1]
= tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) = [0 1 1] [0 1 1] [0]
[0 1 1] @l1 + [0 1 1] @l2 + [2]
[0 0 0] [0 0 0] [1]
>= [0 1 1] [0 1 1] [0]
[0 1 1] @l1 + [0 1 1] @l2 + [2]
[0 0 0] [0 0 0] [1]
= tuple#2(::(@x1,@l1),::(@x2,@l2))
**** Step 6.a:3.a:1.a:2: Assumption WORST_CASE(?,O(1))
+ Considered Problem:
- Weak DPs:
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs')))))
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/1,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
+ Details:
()
**** Step 6.a:3.a:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1))
+ Considered Problem:
- Weak DPs:
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs')))))
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/1,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
RemoveWeakSuffixes
+ Details:
Consider the dependency graph
1:W:mergesort#(@l) -> c_9(mergesort#1#(@l))
-->_1 mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1)):2
2:W:mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
-->_1 mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))):3
3:W:mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs')))))
-->_1 mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2)):4
4:W:mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
-->_3 mergesort#(@l) -> c_9(mergesort#1#(@l)):1
-->_2 mergesort#(@l) -> c_9(mergesort#1#(@l)):1
The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
1: mergesort#(@l) -> c_9(mergesort#1#(@l))
4: mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
3: mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs')))))
2: mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
**** Step 6.a:3.a:1.b:2: EmptyProcessor WORST_CASE(?,O(1))
+ Considered Problem:
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/1,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
EmptyProcessor
+ Details:
The problem is already closed. The intended complexity is O(1).
*** Step 6.a:3.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
- Weak DPs:
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> merge#(mergesort(@l1),mergesort(@l2))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/1,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}}
+ Details:
We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
5: merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
The strictly oriented rules are moved into the weak component.
**** Step 6.a:3.b:1.a:1: NaturalMI WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
- Weak DPs:
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> merge#(mergesort(@l1),mergesort(@l2))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/1,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules}
+ Details:
We apply a matrix interpretation of kind constructor based matrix interpretation:
The following argument positions are considered usable:
uargs(c_2) = {1},
uargs(c_3) = {1},
uargs(c_5) = {1},
uargs(c_7) = {1},
uargs(c_8) = {1}
Following symbols are considered usable:
{merge,merge#1,merge#2,merge#3,mergesort,mergesort#1,mergesort#2,mergesort#3,msplit,msplit#1,msplit#2
,msplit#3,#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#,mergesort#,mergesort#1#,mergesort#2#
,mergesort#3#,msplit#,msplit#1#,msplit#2#,msplit#3#}
TcT has computed the following interpretation:
p(#0) = [0]
p(#EQ) = [0]
p(#GT) = [0]
p(#LT) = [0]
p(#cklt) = [7] x1 + [0]
p(#compare) = [2] x1 + [2] x2 + [2]
p(#false) = [0]
p(#less) = [0]
p(#neg) = [0]
p(#pos) = [1] x1 + [0]
p(#s) = [0]
p(#true) = [0]
p(::) = [1] x2 + [1]
p(merge) = [1] x1 + [1] x2 + [0]
p(merge#1) = [1] x1 + [1] x2 + [0]
p(merge#2) = [1] x1 + [1] x3 + [1]
p(merge#3) = [1] x3 + [1] x5 + [2]
p(mergesort) = [4] x1 + [0]
p(mergesort#1) = [4] x1 + [0]
p(mergesort#2) = [4] x1 + [4]
p(mergesort#3) = [4] x1 + [0]
p(msplit) = [1] x1 + [0]
p(msplit#1) = [1] x1 + [0]
p(msplit#2) = [1] x1 + [1]
p(msplit#3) = [1] x1 + [2]
p(nil) = [0]
p(tuple#2) = [1] x1 + [1] x2 + [0]
p(#cklt#) = [1]
p(#compare#) = [0]
p(#less#) = [0]
p(merge#) = [1] x1 + [0]
p(merge#1#) = [1] x1 + [0]
p(merge#2#) = [1] x3 + [1]
p(merge#3#) = [1] x3 + [1]
p(mergesort#) = [4] x1 + [0]
p(mergesort#1#) = [4] x1 + [0]
p(mergesort#2#) = [4] x1 + [4]
p(mergesort#3#) = [4] x1 + [0]
p(msplit#) = [4]
p(msplit#1#) = [1] x1 + [2]
p(msplit#2#) = [1] x2 + [0]
p(msplit#3#) = [1] x2 + [1] x3 + [0]
p(c_1) = [2]
p(c_2) = [1] x1 + [0]
p(c_3) = [1] x1 + [0]
p(c_4) = [4]
p(c_5) = [1] x1 + [0]
p(c_6) = [0]
p(c_7) = [1] x1 + [0]
p(c_8) = [1] x1 + [0]
p(c_9) = [2]
p(c_10) = [2]
p(c_11) = [1]
p(c_12) = [2] x1 + [0]
p(c_13) = [2]
p(c_14) = [2] x1 + [4] x3 + [0]
p(c_15) = [1] x1 + [1]
p(c_16) = [2] x1 + [4]
p(c_17) = [1]
p(c_18) = [1] x1 + [0]
p(c_19) = [0]
p(c_20) = [0]
p(c_21) = [1]
p(c_22) = [0]
p(c_23) = [4]
p(c_24) = [1]
p(c_25) = [2]
p(c_26) = [0]
p(c_27) = [1]
p(c_28) = [2]
p(c_29) = [1] x1 + [1]
p(c_30) = [0]
p(c_31) = [1]
p(c_32) = [0]
p(c_33) = [2]
p(c_34) = [1]
p(c_35) = [1]
Following rules are strictly oriented:
merge#3#(#true(),@x,@xs,@y,@ys) = [1] @xs + [1]
> [1] @xs + [0]
= c_8(merge#(@xs,::(@y,@ys)))
Following rules are (at-least) weakly oriented:
merge#(@l1,@l2) = [1] @l1 + [0]
>= [1] @l1 + [0]
= c_2(merge#1#(@l1,@l2))
merge#1#(::(@x,@xs),@l2) = [1] @xs + [1]
>= [1] @xs + [1]
= c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) = [1] @xs + [1]
>= [1] @xs + [1]
= c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
merge#3#(#false(),@x,@xs,@y,@ys) = [1] @xs + [1]
>= [1] @xs + [1]
= c_7(merge#(::(@x,@xs),@ys))
mergesort#(@l) = [4] @l + [0]
>= [4] @l + [0]
= mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) = [4] @xs + [4]
>= [4] @xs + [4]
= mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) = [4] @xs' + [8]
>= [4] @xs' + [8]
= mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) = [4] @l1 + [4] @l2 + [0]
>= [4] @l1 + [0]
= merge#(mergesort(@l1),mergesort(@l2))
mergesort#3#(tuple#2(@l1,@l2)) = [4] @l1 + [4] @l2 + [0]
>= [4] @l1 + [0]
= mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) = [4] @l1 + [4] @l2 + [0]
>= [4] @l2 + [0]
= mergesort#(@l2)
merge(@l1,@l2) = [1] @l1 + [1] @l2 + [0]
>= [1] @l1 + [1] @l2 + [0]
= merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) = [1] @l2 + [1] @xs + [1]
>= [1] @l2 + [1] @xs + [1]
= merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) = [1] @l2 + [0]
>= [1] @l2 + [0]
= @l2
merge#2(::(@y,@ys),@x,@xs) = [1] @xs + [1] @ys + [2]
>= [1] @xs + [1] @ys + [2]
= merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) = [1] @xs + [1]
>= [1] @xs + [1]
= ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) = [1] @xs + [1] @ys + [2]
>= [1] @xs + [1] @ys + [2]
= ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) = [1] @xs + [1] @ys + [2]
>= [1] @xs + [1] @ys + [2]
= ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) = [4] @l + [0]
>= [4] @l + [0]
= mergesort#1(@l)
mergesort#1(::(@x1,@xs)) = [4] @xs + [4]
>= [4] @xs + [4]
= mergesort#2(@xs,@x1)
mergesort#1(nil()) = [0]
>= [0]
= nil()
mergesort#2(::(@x2,@xs'),@x1) = [4] @xs' + [8]
>= [4] @xs' + [8]
= mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) = [4]
>= [1]
= ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) = [4] @l1 + [4] @l2 + [0]
>= [4] @l1 + [4] @l2 + [0]
= merge(mergesort(@l1),mergesort(@l2))
msplit(@l) = [1] @l + [0]
>= [1] @l + [0]
= msplit#1(@l)
msplit#1(::(@x1,@xs)) = [1] @xs + [1]
>= [1] @xs + [1]
= msplit#2(@xs,@x1)
msplit#1(nil()) = [0]
>= [0]
= tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) = [1] @xs' + [2]
>= [1] @xs' + [2]
= msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) = [1]
>= [1]
= tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) = [1] @l1 + [1] @l2 + [2]
>= [1] @l1 + [1] @l2 + [2]
= tuple#2(::(@x1,@l1),::(@x2,@l2))
**** Step 6.a:3.b:1.a:2: Assumption WORST_CASE(?,O(1))
+ Considered Problem:
- Strict DPs:
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
- Weak DPs:
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> merge#(mergesort(@l1),mergesort(@l2))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/1,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
+ Details:
()
**** Step 6.a:3.b:1.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
- Weak DPs:
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> merge#(mergesort(@l1),mergesort(@l2))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/1,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}}
+ Details:
We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
4: merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
The strictly oriented rules are moved into the weak component.
***** Step 6.a:3.b:1.b:1.a:1: NaturalMI WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
- Weak DPs:
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> merge#(mergesort(@l1),mergesort(@l2))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/1,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules}
+ Details:
We apply a matrix interpretation of kind constructor based matrix interpretation:
The following argument positions are considered usable:
uargs(c_2) = {1},
uargs(c_3) = {1},
uargs(c_5) = {1},
uargs(c_7) = {1},
uargs(c_8) = {1}
Following symbols are considered usable:
{merge,merge#1,merge#2,merge#3,mergesort,mergesort#1,mergesort#2,mergesort#3,msplit,msplit#1,msplit#2
,msplit#3,#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#,mergesort#,mergesort#1#,mergesort#2#
,mergesort#3#,msplit#,msplit#1#,msplit#2#,msplit#3#}
TcT has computed the following interpretation:
p(#0) = [0]
p(#EQ) = [4]
p(#GT) = [5]
p(#LT) = [0]
p(#cklt) = [2] x1 + [0]
p(#compare) = [7] x1 + [4] x2 + [7]
p(#false) = [0]
p(#less) = [0]
p(#neg) = [0]
p(#pos) = [0]
p(#s) = [1] x1 + [0]
p(#true) = [0]
p(::) = [1] x2 + [2]
p(merge) = [1] x1 + [1] x2 + [0]
p(merge#1) = [1] x1 + [1] x2 + [0]
p(merge#2) = [1] x1 + [1] x3 + [2]
p(merge#3) = [1] x3 + [1] x5 + [4]
p(mergesort) = [1] x1 + [0]
p(mergesort#1) = [1] x1 + [0]
p(mergesort#2) = [1] x1 + [2]
p(mergesort#3) = [1] x1 + [0]
p(msplit) = [1] x1 + [0]
p(msplit#1) = [1] x1 + [0]
p(msplit#2) = [1] x1 + [2]
p(msplit#3) = [1] x1 + [4]
p(nil) = [0]
p(tuple#2) = [1] x1 + [1] x2 + [0]
p(#cklt#) = [2]
p(#compare#) = [1] x1 + [1]
p(#less#) = [4]
p(merge#) = [1] x2 + [0]
p(merge#1#) = [1] x2 + [0]
p(merge#2#) = [1] x1 + [0]
p(merge#3#) = [1] x5 + [2]
p(mergesort#) = [1] x1 + [2]
p(mergesort#1#) = [1] x1 + [2]
p(mergesort#2#) = [1] x1 + [4]
p(mergesort#3#) = [1] x1 + [2]
p(msplit#) = [0]
p(msplit#1#) = [1] x1 + [0]
p(msplit#2#) = [1] x1 + [0]
p(msplit#3#) = [1] x2 + [0]
p(c_1) = [4] x1 + [0]
p(c_2) = [1] x1 + [0]
p(c_3) = [1] x1 + [0]
p(c_4) = [1]
p(c_5) = [1] x1 + [0]
p(c_6) = [0]
p(c_7) = [1] x1 + [1]
p(c_8) = [1] x1 + [0]
p(c_9) = [1]
p(c_10) = [4]
p(c_11) = [2]
p(c_12) = [1]
p(c_13) = [0]
p(c_14) = [4] x1 + [1] x2 + [1] x3 + [2]
p(c_15) = [1] x1 + [0]
p(c_16) = [0]
p(c_17) = [2]
p(c_18) = [1] x1 + [1]
p(c_19) = [1]
p(c_20) = [0]
p(c_21) = [1]
p(c_22) = [1]
p(c_23) = [4]
p(c_24) = [1]
p(c_25) = [0]
p(c_26) = [2]
p(c_27) = [2]
p(c_28) = [2]
p(c_29) = [1] x1 + [2]
p(c_30) = [0]
p(c_31) = [4]
p(c_32) = [0]
p(c_33) = [1]
p(c_34) = [0]
p(c_35) = [1]
Following rules are strictly oriented:
merge#3#(#false(),@x,@xs,@y,@ys) = [1] @ys + [2]
> [1] @ys + [1]
= c_7(merge#(::(@x,@xs),@ys))
Following rules are (at-least) weakly oriented:
merge#(@l1,@l2) = [1] @l2 + [0]
>= [1] @l2 + [0]
= c_2(merge#1#(@l1,@l2))
merge#1#(::(@x,@xs),@l2) = [1] @l2 + [0]
>= [1] @l2 + [0]
= c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) = [1] @ys + [2]
>= [1] @ys + [2]
= c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
merge#3#(#true(),@x,@xs,@y,@ys) = [1] @ys + [2]
>= [1] @ys + [2]
= c_8(merge#(@xs,::(@y,@ys)))
mergesort#(@l) = [1] @l + [2]
>= [1] @l + [2]
= mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) = [1] @xs + [4]
>= [1] @xs + [4]
= mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) = [1] @xs' + [6]
>= [1] @xs' + [6]
= mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) = [1] @l1 + [1] @l2 + [2]
>= [1] @l2 + [0]
= merge#(mergesort(@l1),mergesort(@l2))
mergesort#3#(tuple#2(@l1,@l2)) = [1] @l1 + [1] @l2 + [2]
>= [1] @l1 + [2]
= mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) = [1] @l1 + [1] @l2 + [2]
>= [1] @l2 + [2]
= mergesort#(@l2)
merge(@l1,@l2) = [1] @l1 + [1] @l2 + [0]
>= [1] @l1 + [1] @l2 + [0]
= merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) = [1] @l2 + [1] @xs + [2]
>= [1] @l2 + [1] @xs + [2]
= merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) = [1] @l2 + [0]
>= [1] @l2 + [0]
= @l2
merge#2(::(@y,@ys),@x,@xs) = [1] @xs + [1] @ys + [4]
>= [1] @xs + [1] @ys + [4]
= merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) = [1] @xs + [2]
>= [1] @xs + [2]
= ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) = [1] @xs + [1] @ys + [4]
>= [1] @xs + [1] @ys + [4]
= ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) = [1] @xs + [1] @ys + [4]
>= [1] @xs + [1] @ys + [4]
= ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) = [1] @l + [0]
>= [1] @l + [0]
= mergesort#1(@l)
mergesort#1(::(@x1,@xs)) = [1] @xs + [2]
>= [1] @xs + [2]
= mergesort#2(@xs,@x1)
mergesort#1(nil()) = [0]
>= [0]
= nil()
mergesort#2(::(@x2,@xs'),@x1) = [1] @xs' + [4]
>= [1] @xs' + [4]
= mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) = [2]
>= [2]
= ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) = [1] @l1 + [1] @l2 + [0]
>= [1] @l1 + [1] @l2 + [0]
= merge(mergesort(@l1),mergesort(@l2))
msplit(@l) = [1] @l + [0]
>= [1] @l + [0]
= msplit#1(@l)
msplit#1(::(@x1,@xs)) = [1] @xs + [2]
>= [1] @xs + [2]
= msplit#2(@xs,@x1)
msplit#1(nil()) = [0]
>= [0]
= tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) = [1] @xs' + [4]
>= [1] @xs' + [4]
= msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) = [2]
>= [2]
= tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) = [1] @l1 + [1] @l2 + [4]
>= [1] @l1 + [1] @l2 + [4]
= tuple#2(::(@x1,@l1),::(@x2,@l2))
***** Step 6.a:3.b:1.b:1.a:2: Assumption WORST_CASE(?,O(1))
+ Considered Problem:
- Strict DPs:
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
- Weak DPs:
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> merge#(mergesort(@l1),mergesort(@l2))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/1,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
+ Details:
()
***** Step 6.a:3.b:1.b:1.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
- Weak DPs:
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> merge#(mergesort(@l1),mergesort(@l2))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/1,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}}
+ Details:
We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
2: merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
3: merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
Consider the set of all dependency pairs
1: merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
2: merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
3: merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
4: merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
5: merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
6: mergesort#(@l) -> mergesort#1#(@l)
7: mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
8: mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
9: mergesort#3#(tuple#2(@l1,@l2)) -> merge#(mergesort(@l1),mergesort(@l2))
10: mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
11: mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
Processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}induces the complexity certificateTIME (?,O(n^1))
SPACE(?,?)on application of the dependency pairs
{2,3}
These cover all (indirect) predecessors of dependency pairs
{2,3,4,5}
their number of applications is equally bounded.
The dependency pairs are shifted into the weak component.
****** Step 6.a:3.b:1.b:1.b:1.a:1: NaturalMI WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
- Weak DPs:
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> merge#(mergesort(@l1),mergesort(@l2))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/1,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules}
+ Details:
We apply a matrix interpretation of kind constructor based matrix interpretation:
The following argument positions are considered usable:
uargs(c_2) = {1},
uargs(c_3) = {1},
uargs(c_5) = {1},
uargs(c_7) = {1},
uargs(c_8) = {1}
Following symbols are considered usable:
{merge,merge#1,merge#2,merge#3,mergesort,mergesort#1,mergesort#2,mergesort#3,msplit,msplit#1,msplit#2
,msplit#3,#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#,mergesort#,mergesort#1#,mergesort#2#
,mergesort#3#,msplit#,msplit#1#,msplit#2#,msplit#3#}
TcT has computed the following interpretation:
p(#0) = [0]
p(#EQ) = [0]
p(#GT) = [0]
p(#LT) = [0]
p(#cklt) = [7] x1 + [1]
p(#compare) = [2] x1 + [2] x2 + [2]
p(#false) = [0]
p(#less) = [2] x1 + [0]
p(#neg) = [1]
p(#pos) = [0]
p(#s) = [1]
p(#true) = [0]
p(::) = [1] x2 + [1]
p(merge) = [1] x1 + [1] x2 + [0]
p(merge#1) = [1] x1 + [1] x2 + [0]
p(merge#2) = [1] x1 + [1] x3 + [1]
p(merge#3) = [1] x3 + [1] x5 + [2]
p(mergesort) = [2] x1 + [0]
p(mergesort#1) = [2] x1 + [0]
p(mergesort#2) = [2] x1 + [2]
p(mergesort#3) = [2] x1 + [0]
p(msplit) = [1] x1 + [0]
p(msplit#1) = [1] x1 + [0]
p(msplit#2) = [1] x1 + [1]
p(msplit#3) = [1] x1 + [2]
p(nil) = [0]
p(tuple#2) = [1] x1 + [1] x2 + [0]
p(#cklt#) = [1]
p(#compare#) = [2] x1 + [1] x2 + [0]
p(#less#) = [2] x1 + [2]
p(merge#) = [2] x1 + [2] x2 + [0]
p(merge#1#) = [2] x1 + [2] x2 + [0]
p(merge#2#) = [2] x1 + [2] x3 + [1]
p(merge#3#) = [2] x3 + [2] x5 + [2]
p(mergesort#) = [4] x1 + [0]
p(mergesort#1#) = [4] x1 + [0]
p(mergesort#2#) = [4] x1 + [4]
p(mergesort#3#) = [4] x1 + [0]
p(msplit#) = [2] x1 + [4]
p(msplit#1#) = [0]
p(msplit#2#) = [4] x1 + [4] x2 + [0]
p(msplit#3#) = [2] x1 + [1]
p(c_1) = [1]
p(c_2) = [1] x1 + [0]
p(c_3) = [1] x1 + [0]
p(c_4) = [2]
p(c_5) = [1] x1 + [0]
p(c_6) = [2]
p(c_7) = [1] x1 + [0]
p(c_8) = [1] x1 + [0]
p(c_9) = [1] x1 + [1]
p(c_10) = [4]
p(c_11) = [1]
p(c_12) = [1] x1 + [0]
p(c_13) = [1]
p(c_14) = [2] x1 + [2] x2 + [0]
p(c_15) = [1] x1 + [0]
p(c_16) = [4] x1 + [4]
p(c_17) = [1]
p(c_18) = [4] x1 + [0]
p(c_19) = [0]
p(c_20) = [0]
p(c_21) = [1]
p(c_22) = [1]
p(c_23) = [1]
p(c_24) = [1]
p(c_25) = [0]
p(c_26) = [1]
p(c_27) = [1]
p(c_28) = [0]
p(c_29) = [1] x1 + [0]
p(c_30) = [0]
p(c_31) = [1]
p(c_32) = [1]
p(c_33) = [2] x1 + [4]
p(c_34) = [0]
p(c_35) = [1] x1 + [1]
Following rules are strictly oriented:
merge#1#(::(@x,@xs),@l2) = [2] @l2 + [2] @xs + [2]
> [2] @l2 + [2] @xs + [1]
= c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) = [2] @xs + [2] @ys + [3]
> [2] @xs + [2] @ys + [2]
= c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
Following rules are (at-least) weakly oriented:
merge#(@l1,@l2) = [2] @l1 + [2] @l2 + [0]
>= [2] @l1 + [2] @l2 + [0]
= c_2(merge#1#(@l1,@l2))
merge#3#(#false(),@x,@xs,@y,@ys) = [2] @xs + [2] @ys + [2]
>= [2] @xs + [2] @ys + [2]
= c_7(merge#(::(@x,@xs),@ys))
merge#3#(#true(),@x,@xs,@y,@ys) = [2] @xs + [2] @ys + [2]
>= [2] @xs + [2] @ys + [2]
= c_8(merge#(@xs,::(@y,@ys)))
mergesort#(@l) = [4] @l + [0]
>= [4] @l + [0]
= mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) = [4] @xs + [4]
>= [4] @xs + [4]
= mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) = [4] @xs' + [8]
>= [4] @xs' + [8]
= mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) = [4] @l1 + [4] @l2 + [0]
>= [4] @l1 + [4] @l2 + [0]
= merge#(mergesort(@l1),mergesort(@l2))
mergesort#3#(tuple#2(@l1,@l2)) = [4] @l1 + [4] @l2 + [0]
>= [4] @l1 + [0]
= mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) = [4] @l1 + [4] @l2 + [0]
>= [4] @l2 + [0]
= mergesort#(@l2)
merge(@l1,@l2) = [1] @l1 + [1] @l2 + [0]
>= [1] @l1 + [1] @l2 + [0]
= merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) = [1] @l2 + [1] @xs + [1]
>= [1] @l2 + [1] @xs + [1]
= merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) = [1] @l2 + [0]
>= [1] @l2 + [0]
= @l2
merge#2(::(@y,@ys),@x,@xs) = [1] @xs + [1] @ys + [2]
>= [1] @xs + [1] @ys + [2]
= merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) = [1] @xs + [1]
>= [1] @xs + [1]
= ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) = [1] @xs + [1] @ys + [2]
>= [1] @xs + [1] @ys + [2]
= ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) = [1] @xs + [1] @ys + [2]
>= [1] @xs + [1] @ys + [2]
= ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) = [2] @l + [0]
>= [2] @l + [0]
= mergesort#1(@l)
mergesort#1(::(@x1,@xs)) = [2] @xs + [2]
>= [2] @xs + [2]
= mergesort#2(@xs,@x1)
mergesort#1(nil()) = [0]
>= [0]
= nil()
mergesort#2(::(@x2,@xs'),@x1) = [2] @xs' + [4]
>= [2] @xs' + [4]
= mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) = [2]
>= [1]
= ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) = [2] @l1 + [2] @l2 + [0]
>= [2] @l1 + [2] @l2 + [0]
= merge(mergesort(@l1),mergesort(@l2))
msplit(@l) = [1] @l + [0]
>= [1] @l + [0]
= msplit#1(@l)
msplit#1(::(@x1,@xs)) = [1] @xs + [1]
>= [1] @xs + [1]
= msplit#2(@xs,@x1)
msplit#1(nil()) = [0]
>= [0]
= tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) = [1] @xs' + [2]
>= [1] @xs' + [2]
= msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) = [1]
>= [1]
= tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) = [1] @l1 + [1] @l2 + [2]
>= [1] @l1 + [1] @l2 + [2]
= tuple#2(::(@x1,@l1),::(@x2,@l2))
****** Step 6.a:3.b:1.b:1.b:1.a:2: Assumption WORST_CASE(?,O(1))
+ Considered Problem:
- Strict DPs:
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
- Weak DPs:
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> merge#(mergesort(@l1),mergesort(@l2))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/1,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
+ Details:
()
****** Step 6.a:3.b:1.b:1.b:1.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
- Weak DPs:
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> merge#(mergesort(@l1),mergesort(@l2))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/1,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}}
+ Details:
We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
1: merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
Consider the set of all dependency pairs
1: merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
2: merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
3: merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
4: merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
5: merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
6: mergesort#(@l) -> mergesort#1#(@l)
7: mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
8: mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
9: mergesort#3#(tuple#2(@l1,@l2)) -> merge#(mergesort(@l1),mergesort(@l2))
10: mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
11: mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
Processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}induces the complexity certificateTIME (?,O(n^1))
SPACE(?,?)on application of the dependency pairs
{1}
These cover all (indirect) predecessors of dependency pairs
{1,2,3,4,5}
their number of applications is equally bounded.
The dependency pairs are shifted into the weak component.
******* Step 6.a:3.b:1.b:1.b:1.b:1.a:1: NaturalMI WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
- Weak DPs:
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> merge#(mergesort(@l1),mergesort(@l2))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/1,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules}
+ Details:
We apply a matrix interpretation of kind constructor based matrix interpretation:
The following argument positions are considered usable:
uargs(c_2) = {1},
uargs(c_3) = {1},
uargs(c_5) = {1},
uargs(c_7) = {1},
uargs(c_8) = {1}
Following symbols are considered usable:
{merge,merge#1,merge#2,merge#3,mergesort,mergesort#1,mergesort#2,mergesort#3,msplit,msplit#1,msplit#2
,msplit#3,#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#,mergesort#,mergesort#1#,mergesort#2#
,mergesort#3#,msplit#,msplit#1#,msplit#2#,msplit#3#}
TcT has computed the following interpretation:
p(#0) = [3]
p(#EQ) = [0]
p(#GT) = [0]
p(#LT) = [0]
p(#cklt) = [5] x1 + [0]
p(#compare) = [2] x1 + [3]
p(#false) = [0]
p(#less) = [0]
p(#neg) = [2]
p(#pos) = [1] x1 + [0]
p(#s) = [1] x1 + [3]
p(#true) = [0]
p(::) = [1] x2 + [2]
p(merge) = [1] x1 + [1] x2 + [0]
p(merge#1) = [1] x1 + [1] x2 + [0]
p(merge#2) = [1] x1 + [1] x3 + [2]
p(merge#3) = [1] x3 + [1] x5 + [4]
p(mergesort) = [1] x1 + [0]
p(mergesort#1) = [1] x1 + [0]
p(mergesort#2) = [1] x1 + [2]
p(mergesort#3) = [1] x1 + [0]
p(msplit) = [1] x1 + [0]
p(msplit#1) = [1] x1 + [0]
p(msplit#2) = [1] x1 + [2]
p(msplit#3) = [1] x1 + [4]
p(nil) = [0]
p(tuple#2) = [1] x1 + [1] x2 + [0]
p(#cklt#) = [1] x1 + [0]
p(#compare#) = [4] x2 + [4]
p(#less#) = [4]
p(merge#) = [1] x1 + [1] x2 + [1]
p(merge#1#) = [1] x1 + [1] x2 + [0]
p(merge#2#) = [1] x1 + [1] x3 + [2]
p(merge#3#) = [1] x3 + [1] x5 + [3]
p(mergesort#) = [2] x1 + [1]
p(mergesort#1#) = [2] x1 + [1]
p(mergesort#2#) = [2] x1 + [5]
p(mergesort#3#) = [2] x1 + [1]
p(msplit#) = [1] x1 + [1]
p(msplit#1#) = [2] x1 + [0]
p(msplit#2#) = [4] x1 + [1] x2 + [0]
p(msplit#3#) = [1] x1 + [2] x2 + [2]
p(c_1) = [0]
p(c_2) = [1] x1 + [0]
p(c_3) = [1] x1 + [0]
p(c_4) = [0]
p(c_5) = [1] x1 + [1]
p(c_6) = [2]
p(c_7) = [1] x1 + [0]
p(c_8) = [1] x1 + [0]
p(c_9) = [1] x1 + [4]
p(c_10) = [2] x1 + [1]
p(c_11) = [1]
p(c_12) = [4]
p(c_13) = [0]
p(c_14) = [1] x1 + [1] x3 + [0]
p(c_15) = [1]
p(c_16) = [1]
p(c_17) = [1]
p(c_18) = [2]
p(c_19) = [1]
p(c_20) = [1]
p(c_21) = [0]
p(c_22) = [0]
p(c_23) = [1]
p(c_24) = [1]
p(c_25) = [0]
p(c_26) = [0]
p(c_27) = [2]
p(c_28) = [4]
p(c_29) = [2] x1 + [1]
p(c_30) = [0]
p(c_31) = [2]
p(c_32) = [4]
p(c_33) = [1]
p(c_34) = [2]
p(c_35) = [1]
Following rules are strictly oriented:
merge#(@l1,@l2) = [1] @l1 + [1] @l2 + [1]
> [1] @l1 + [1] @l2 + [0]
= c_2(merge#1#(@l1,@l2))
Following rules are (at-least) weakly oriented:
merge#1#(::(@x,@xs),@l2) = [1] @l2 + [1] @xs + [2]
>= [1] @l2 + [1] @xs + [2]
= c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) = [1] @xs + [1] @ys + [4]
>= [1] @xs + [1] @ys + [4]
= c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
merge#3#(#false(),@x,@xs,@y,@ys) = [1] @xs + [1] @ys + [3]
>= [1] @xs + [1] @ys + [3]
= c_7(merge#(::(@x,@xs),@ys))
merge#3#(#true(),@x,@xs,@y,@ys) = [1] @xs + [1] @ys + [3]
>= [1] @xs + [1] @ys + [3]
= c_8(merge#(@xs,::(@y,@ys)))
mergesort#(@l) = [2] @l + [1]
>= [2] @l + [1]
= mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) = [2] @xs + [5]
>= [2] @xs + [5]
= mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) = [2] @xs' + [9]
>= [2] @xs' + [9]
= mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) = [2] @l1 + [2] @l2 + [1]
>= [1] @l1 + [1] @l2 + [1]
= merge#(mergesort(@l1),mergesort(@l2))
mergesort#3#(tuple#2(@l1,@l2)) = [2] @l1 + [2] @l2 + [1]
>= [2] @l1 + [1]
= mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) = [2] @l1 + [2] @l2 + [1]
>= [2] @l2 + [1]
= mergesort#(@l2)
merge(@l1,@l2) = [1] @l1 + [1] @l2 + [0]
>= [1] @l1 + [1] @l2 + [0]
= merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) = [1] @l2 + [1] @xs + [2]
>= [1] @l2 + [1] @xs + [2]
= merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) = [1] @l2 + [0]
>= [1] @l2 + [0]
= @l2
merge#2(::(@y,@ys),@x,@xs) = [1] @xs + [1] @ys + [4]
>= [1] @xs + [1] @ys + [4]
= merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) = [1] @xs + [2]
>= [1] @xs + [2]
= ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) = [1] @xs + [1] @ys + [4]
>= [1] @xs + [1] @ys + [4]
= ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) = [1] @xs + [1] @ys + [4]
>= [1] @xs + [1] @ys + [4]
= ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) = [1] @l + [0]
>= [1] @l + [0]
= mergesort#1(@l)
mergesort#1(::(@x1,@xs)) = [1] @xs + [2]
>= [1] @xs + [2]
= mergesort#2(@xs,@x1)
mergesort#1(nil()) = [0]
>= [0]
= nil()
mergesort#2(::(@x2,@xs'),@x1) = [1] @xs' + [4]
>= [1] @xs' + [4]
= mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) = [2]
>= [2]
= ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) = [1] @l1 + [1] @l2 + [0]
>= [1] @l1 + [1] @l2 + [0]
= merge(mergesort(@l1),mergesort(@l2))
msplit(@l) = [1] @l + [0]
>= [1] @l + [0]
= msplit#1(@l)
msplit#1(::(@x1,@xs)) = [1] @xs + [2]
>= [1] @xs + [2]
= msplit#2(@xs,@x1)
msplit#1(nil()) = [0]
>= [0]
= tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) = [1] @xs' + [4]
>= [1] @xs' + [4]
= msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) = [2]
>= [2]
= tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) = [1] @l1 + [1] @l2 + [4]
>= [1] @l1 + [1] @l2 + [4]
= tuple#2(::(@x1,@l1),::(@x2,@l2))
******* Step 6.a:3.b:1.b:1.b:1.b:1.a:2: Assumption WORST_CASE(?,O(1))
+ Considered Problem:
- Weak DPs:
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> merge#(mergesort(@l1),mergesort(@l2))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/1,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
+ Details:
()
******* Step 6.a:3.b:1.b:1.b:1.b:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1))
+ Considered Problem:
- Weak DPs:
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> merge#(mergesort(@l1),mergesort(@l2))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/1,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
RemoveWeakSuffixes
+ Details:
Consider the dependency graph
1:W:merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
-->_1 merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs)):2
2:W:merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
-->_1 merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys)):3
3:W:merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
-->_1 merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys))):5
-->_1 merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys)):4
4:W:merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
-->_1 merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2)):1
5:W:merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
-->_1 merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2)):1
6:W:mergesort#(@l) -> mergesort#1#(@l)
-->_1 mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1):7
7:W:mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
-->_1 mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs')))):8
8:W:mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
-->_1 mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2):11
-->_1 mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1):10
-->_1 mergesort#3#(tuple#2(@l1,@l2)) -> merge#(mergesort(@l1),mergesort(@l2)):9
9:W:mergesort#3#(tuple#2(@l1,@l2)) -> merge#(mergesort(@l1),mergesort(@l2))
-->_1 merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2)):1
10:W:mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
-->_1 mergesort#(@l) -> mergesort#1#(@l):6
11:W:mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
-->_1 mergesort#(@l) -> mergesort#1#(@l):6
The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
6: mergesort#(@l) -> mergesort#1#(@l)
11: mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
8: mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
7: mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
10: mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
9: mergesort#3#(tuple#2(@l1,@l2)) -> merge#(mergesort(@l1),mergesort(@l2))
1: merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
5: merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
3: merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
2: merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
4: merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
******* Step 6.a:3.b:1.b:1.b:1.b:1.b:2: EmptyProcessor WORST_CASE(?,O(1))
+ Considered Problem:
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/1,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
EmptyProcessor
+ Details:
The problem is already closed. The intended complexity is O(1).
** Step 6.b:1: RemoveWeakSuffixes WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
msplit#(@l) -> c_15(msplit#1#(@l))
msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
- Weak DPs:
merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
RemoveWeakSuffixes
+ Details:
Consider the dependency graph
1:S:mergesort#(@l) -> c_9(mergesort#1#(@l))
-->_1 mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1)):2
2:S:mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
-->_1 mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs')))):3
3:S:mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
-->_2 msplit#(@l) -> c_15(msplit#1#(@l)):5
-->_1 mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2)):4
4:S:mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
-->_1 merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2)):8
-->_3 mergesort#(@l) -> c_9(mergesort#1#(@l)):1
-->_2 mergesort#(@l) -> c_9(mergesort#1#(@l)):1
5:S:msplit#(@l) -> c_15(msplit#1#(@l))
-->_1 msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1)):6
6:S:msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
-->_1 msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs')):7
7:S:msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
-->_1 msplit#(@l) -> c_15(msplit#1#(@l)):5
8:W:merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
-->_1 merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs)):9
9:W:merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
-->_1 merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys)):10
10:W:merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
-->_1 merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys))):12
-->_1 merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys)):11
11:W:merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
-->_1 merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2)):8
12:W:merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
-->_1 merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2)):8
The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
8: merge#(@l1,@l2) -> c_2(merge#1#(@l1,@l2))
12: merge#3#(#true(),@x,@xs,@y,@ys) -> c_8(merge#(@xs,::(@y,@ys)))
10: merge#2#(::(@y,@ys),@x,@xs) -> c_5(merge#3#(#less(@x,@y),@x,@xs,@y,@ys))
9: merge#1#(::(@x,@xs),@l2) -> c_3(merge#2#(@l2,@x,@xs))
11: merge#3#(#false(),@x,@xs,@y,@ys) -> c_7(merge#(::(@x,@xs),@ys))
** Step 6.b:2: SimplifyRHS WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
msplit#(@l) -> c_15(msplit#1#(@l))
msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/3,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
SimplifyRHS
+ Details:
Consider the dependency graph
1:S:mergesort#(@l) -> c_9(mergesort#1#(@l))
-->_1 mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1)):2
2:S:mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
-->_1 mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs')))):3
3:S:mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
-->_2 msplit#(@l) -> c_15(msplit#1#(@l)):5
-->_1 mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2)):4
4:S:mergesort#3#(tuple#2(@l1,@l2)) -> c_14(merge#(mergesort(@l1),mergesort(@l2))
,mergesort#(@l1)
,mergesort#(@l2))
-->_3 mergesort#(@l) -> c_9(mergesort#1#(@l)):1
-->_2 mergesort#(@l) -> c_9(mergesort#1#(@l)):1
5:S:msplit#(@l) -> c_15(msplit#1#(@l))
-->_1 msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1)):6
6:S:msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
-->_1 msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs')):7
7:S:msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
-->_1 msplit#(@l) -> c_15(msplit#1#(@l)):5
Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified:
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(mergesort#(@l1),mergesort#(@l2))
** Step 6.b:3: UsableRules WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(mergesort#(@l1),mergesort#(@l2))
msplit#(@l) -> c_15(msplit#1#(@l))
msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
- Weak TRS:
#cklt(#EQ()) -> #false()
#cklt(#GT()) -> #false()
#cklt(#LT()) -> #true()
#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)
#less(@x,@y) -> #cklt(#compare(@x,@y))
merge(@l1,@l2) -> merge#1(@l1,@l2)
merge#1(::(@x,@xs),@l2) -> merge#2(@l2,@x,@xs)
merge#1(nil(),@l2) -> @l2
merge#2(::(@y,@ys),@x,@xs) -> merge#3(#less(@x,@y),@x,@xs,@y,@ys)
merge#2(nil(),@x,@xs) -> ::(@x,@xs)
merge#3(#false(),@x,@xs,@y,@ys) -> ::(@y,merge(::(@x,@xs),@ys))
merge#3(#true(),@x,@xs,@y,@ys) -> ::(@x,merge(@xs,::(@y,@ys)))
mergesort(@l) -> mergesort#1(@l)
mergesort#1(::(@x1,@xs)) -> mergesort#2(@xs,@x1)
mergesort#1(nil()) -> nil()
mergesort#2(::(@x2,@xs'),@x1) -> mergesort#3(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2(nil(),@x1) -> ::(@x1,nil())
mergesort#3(tuple#2(@l1,@l2)) -> merge(mergesort(@l1),mergesort(@l2))
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/2,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
UsableRules
+ Details:
We replace rewrite rules by usable rules:
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(mergesort#(@l1),mergesort#(@l2))
msplit#(@l) -> c_15(msplit#1#(@l))
msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
** Step 6.b:4: DecomposeDG WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(mergesort#(@l1),mergesort#(@l2))
msplit#(@l) -> c_15(msplit#1#(@l))
msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
- Weak TRS:
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/2,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
DecomposeDG {onSelection = all below first cut in WDG, onUpper = Just someStrategy, onLower = Nothing}
+ Details:
We decompose the input problem according to the dependency graph into the upper component
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(mergesort#(@l1),mergesort#(@l2))
and a lower component
msplit#(@l) -> c_15(msplit#1#(@l))
msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
Further, following extension rules are added to the lower component.
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2#(::(@x2,@xs'),@x1) -> msplit#(::(@x1,::(@x2,@xs')))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
*** Step 6.b:4.a:1: PredecessorEstimationCP WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(mergesort#(@l1),mergesort#(@l2))
- Weak TRS:
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/2,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 3, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}}
+ Details:
We first use the processor NaturalMI {miDimension = 3, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
3: mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
Consider the set of all dependency pairs
1: mergesort#(@l) -> c_9(mergesort#1#(@l))
2: mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
3: mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
4: mergesort#3#(tuple#2(@l1,@l2)) -> c_14(mergesort#(@l1),mergesort#(@l2))
Processor NaturalMI {miDimension = 3, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}induces the complexity certificateTIME (?,O(n^1))
SPACE(?,?)on application of the dependency pairs
{3}
These cover all (indirect) predecessors of dependency pairs
{1,2,3,4}
their number of applications is equally bounded.
The dependency pairs are shifted into the weak component.
**** Step 6.b:4.a:1.a:1: NaturalMI WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(mergesort#(@l1),mergesort#(@l2))
- Weak TRS:
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/2,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
NaturalMI {miDimension = 3, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules}
+ Details:
We apply a matrix interpretation of kind constructor based matrix interpretation (containing no more than 1 non-zero interpretation-entries in the diagonal of the component-wise maxima):
The following argument positions are considered usable:
uargs(c_9) = {1},
uargs(c_10) = {1},
uargs(c_12) = {1},
uargs(c_14) = {1,2}
Following symbols are considered usable:
{msplit,msplit#1,msplit#2,msplit#3,#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#,mergesort#
,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#,msplit#3#}
TcT has computed the following interpretation:
p(#0) = [0]
[0]
[0]
p(#EQ) = [0]
[0]
[0]
p(#GT) = [0]
[0]
[0]
p(#LT) = [0]
[0]
[0]
p(#cklt) = [0]
[0]
[0]
p(#compare) = [0]
[0]
[0]
p(#false) = [0]
[0]
[0]
p(#less) = [0]
[0]
[0]
p(#neg) = [0]
[0]
[0]
p(#pos) = [0]
[0]
[0]
p(#s) = [0]
[0]
[0]
p(#true) = [0]
[0]
[0]
p(::) = [0 0 0] [0 1 0] [0]
[0 0 0] x1 + [0 0 1] x2 + [0]
[0 0 1] [0 0 1] [1]
p(merge) = [0]
[0]
[0]
p(merge#1) = [0]
[0]
[0]
p(merge#2) = [0]
[0]
[0]
p(merge#3) = [0]
[0]
[0]
p(mergesort) = [0]
[0]
[0]
p(mergesort#1) = [0]
[0]
[0]
p(mergesort#2) = [0]
[0]
[0]
p(mergesort#3) = [0]
[0]
[0]
p(msplit) = [1 0 0] [0]
[0 0 0] x1 + [1]
[0 0 1] [0]
p(msplit#1) = [1 0 0] [0]
[0 0 0] x1 + [1]
[0 0 1] [0]
p(msplit#2) = [0 1 0] [0 0 0] [0]
[0 0 0] x1 + [0 0 0] x2 + [1]
[0 0 1] [0 0 1] [1]
p(msplit#3) = [0 0 1] [0 0 0] [0 0 0] [0]
[0 0 0] x1 + [0 0 0] x2 + [0 0 0] x3 + [1]
[0 1 1] [0 0 1] [0 0 1] [1]
p(nil) = [0]
[0]
[0]
p(tuple#2) = [0 1 0] [0 1 0] [0]
[0 0 0] x1 + [0 0 0] x2 + [1]
[0 0 1] [0 0 1] [0]
p(#cklt#) = [0]
[0]
[0]
p(#compare#) = [0]
[0]
[0]
p(#less#) = [0]
[0]
[0]
p(merge#) = [0]
[0]
[0]
p(merge#1#) = [0]
[0]
[0]
p(merge#2#) = [0]
[0]
[0]
p(merge#3#) = [0]
[0]
[0]
p(mergesort#) = [0 1 0] [0]
[0 0 1] x1 + [0]
[1 1 0] [0]
p(mergesort#1#) = [0 1 0] [0]
[1 1 0] x1 + [0]
[1 0 1] [0]
p(mergesort#2#) = [0 0 1] [0]
[0 1 0] x1 + [0]
[0 1 1] [0]
p(mergesort#3#) = [1 0 0] [0]
[0 0 1] x1 + [1]
[0 0 1] [1]
p(msplit#) = [0 1 0] [0]
[1 0 0] x1 + [0]
[0 1 0] [1]
p(msplit#1#) = [0]
[0]
[0]
p(msplit#2#) = [0]
[0]
[0]
p(msplit#3#) = [0]
[0]
[0]
p(c_1) = [0]
[0]
[0]
p(c_2) = [0]
[0]
[0]
p(c_3) = [0]
[0]
[0]
p(c_4) = [0]
[0]
[0]
p(c_5) = [0]
[0]
[0]
p(c_6) = [0]
[0]
[0]
p(c_7) = [0]
[0]
[0]
p(c_8) = [0]
[0]
[0]
p(c_9) = [1 0 0] [0]
[0 0 0] x1 + [0]
[0 1 0] [0]
p(c_10) = [1 0 0] [0]
[0 1 0] x1 + [0]
[1 1 0] [0]
p(c_11) = [0]
[0]
[0]
p(c_12) = [1 0 0] [0 0 0] [0]
[0 0 0] x1 + [0 0 0] x2 + [0]
[1 0 0] [1 0 0] [0]
p(c_13) = [0]
[0]
[0]
p(c_14) = [1 0 0] [1 0 0] [0]
[0 1 0] x1 + [0 0 0] x2 + [0]
[0 1 0] [0 0 0] [0]
p(c_15) = [0]
[0]
[0]
p(c_16) = [0]
[0]
[0]
p(c_17) = [0]
[0]
[0]
p(c_18) = [0]
[0]
[0]
p(c_19) = [0]
[0]
[0]
p(c_20) = [0]
[0]
[0]
p(c_21) = [0]
[0]
[0]
p(c_22) = [0]
[0]
[0]
p(c_23) = [0]
[0]
[0]
p(c_24) = [0]
[0]
[0]
p(c_25) = [0]
[0]
[0]
p(c_26) = [0]
[0]
[0]
p(c_27) = [0]
[0]
[0]
p(c_28) = [0]
[0]
[0]
p(c_29) = [0]
[0]
[0]
p(c_30) = [0]
[0]
[0]
p(c_31) = [0]
[0]
[0]
p(c_32) = [0]
[0]
[0]
p(c_33) = [0]
[0]
[0]
p(c_34) = [0]
[0]
[0]
p(c_35) = [0]
[0]
[0]
Following rules are strictly oriented:
mergesort#2#(::(@x2,@xs'),@x1) = [0 0 1] [0 0 1] [1]
[0 0 0] @x2 + [0 0 1] @xs' + [0]
[0 0 1] [0 0 2] [1]
> [0 0 0] [0 0 1] [0]
[0 0 0] @x2 + [0 0 0] @xs' + [0]
[0 0 1] [0 0 2] [1]
= c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs')))),msplit#(::(@x1,::(@x2,@xs'))))
Following rules are (at-least) weakly oriented:
mergesort#(@l) = [0 1 0] [0]
[0 0 1] @l + [0]
[1 1 0] [0]
>= [0 1 0] [0]
[0 0 0] @l + [0]
[1 1 0] [0]
= c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) = [0 0 0] [0 0 1] [0]
[0 0 0] @x1 + [0 1 1] @xs + [0]
[0 0 1] [0 1 1] [1]
>= [0 0 1] [0]
[0 1 0] @xs + [0]
[0 1 1] [0]
= c_10(mergesort#2#(@xs,@x1))
mergesort#3#(tuple#2(@l1,@l2)) = [0 1 0] [0 1 0] [0]
[0 0 1] @l1 + [0 0 1] @l2 + [1]
[0 0 1] [0 0 1] [1]
>= [0 1 0] [0 1 0] [0]
[0 0 1] @l1 + [0 0 0] @l2 + [0]
[0 0 1] [0 0 0] [0]
= c_14(mergesort#(@l1),mergesort#(@l2))
msplit(@l) = [1 0 0] [0]
[0 0 0] @l + [1]
[0 0 1] [0]
>= [1 0 0] [0]
[0 0 0] @l + [1]
[0 0 1] [0]
= msplit#1(@l)
msplit#1(::(@x1,@xs)) = [0 0 0] [0 1 0] [0]
[0 0 0] @x1 + [0 0 0] @xs + [1]
[0 0 1] [0 0 1] [1]
>= [0 0 0] [0 1 0] [0]
[0 0 0] @x1 + [0 0 0] @xs + [1]
[0 0 1] [0 0 1] [1]
= msplit#2(@xs,@x1)
msplit#1(nil()) = [0]
[1]
[0]
>= [0]
[1]
[0]
= tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) = [0 0 0] [0 0 0] [0 0 1] [0]
[0 0 0] @x1 + [0 0 0] @x2 + [0 0 0] @xs' + [1]
[0 0 1] [0 0 1] [0 0 1] [2]
>= [0 0 0] [0 0 0] [0 0 1] [0]
[0 0 0] @x1 + [0 0 0] @x2 + [0 0 0] @xs' + [1]
[0 0 1] [0 0 1] [0 0 1] [2]
= msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) = [0 0 0] [0]
[0 0 0] @x1 + [1]
[0 0 1] [1]
>= [0 0 0] [0]
[0 0 0] @x1 + [1]
[0 0 1] [1]
= tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) = [0 0 1] [0 0 1] [0 0 0] [0 0 0] [0]
[0 0 0] @l1 + [0 0 0] @l2 + [0 0 0] @x1 + [0 0 0] @x2 + [1]
[0 0 1] [0 0 1] [0 0 1] [0 0 1] [2]
>= [0 0 1] [0 0 1] [0 0 0] [0 0 0] [0]
[0 0 0] @l1 + [0 0 0] @l2 + [0 0 0] @x1 + [0 0 0] @x2 + [1]
[0 0 1] [0 0 1] [0 0 1] [0 0 1] [2]
= tuple#2(::(@x1,@l1),::(@x2,@l2))
**** Step 6.b:4.a:1.a:2: Assumption WORST_CASE(?,O(1))
+ Considered Problem:
- Strict DPs:
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(mergesort#(@l1),mergesort#(@l2))
- Weak DPs:
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
- Weak TRS:
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/2,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
+ Details:
()
**** Step 6.b:4.a:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1))
+ Considered Problem:
- Weak DPs:
mergesort#(@l) -> c_9(mergesort#1#(@l))
mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
mergesort#3#(tuple#2(@l1,@l2)) -> c_14(mergesort#(@l1),mergesort#(@l2))
- Weak TRS:
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/2,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
RemoveWeakSuffixes
+ Details:
Consider the dependency graph
1:W:mergesort#(@l) -> c_9(mergesort#1#(@l))
-->_1 mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1)):2
2:W:mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
-->_1 mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs')))):3
3:W:mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
-->_1 mergesort#3#(tuple#2(@l1,@l2)) -> c_14(mergesort#(@l1),mergesort#(@l2)):4
4:W:mergesort#3#(tuple#2(@l1,@l2)) -> c_14(mergesort#(@l1),mergesort#(@l2))
-->_2 mergesort#(@l) -> c_9(mergesort#1#(@l)):1
-->_1 mergesort#(@l) -> c_9(mergesort#1#(@l)):1
The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
1: mergesort#(@l) -> c_9(mergesort#1#(@l))
4: mergesort#3#(tuple#2(@l1,@l2)) -> c_14(mergesort#(@l1),mergesort#(@l2))
3: mergesort#2#(::(@x2,@xs'),@x1) -> c_12(mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
,msplit#(::(@x1,::(@x2,@xs'))))
2: mergesort#1#(::(@x1,@xs)) -> c_10(mergesort#2#(@xs,@x1))
**** Step 6.b:4.a:1.b:2: EmptyProcessor WORST_CASE(?,O(1))
+ Considered Problem:
- Weak TRS:
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/2,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
EmptyProcessor
+ Details:
The problem is already closed. The intended complexity is O(1).
*** Step 6.b:4.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
msplit#(@l) -> c_15(msplit#1#(@l))
msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
- Weak DPs:
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2#(::(@x2,@xs'),@x1) -> msplit#(::(@x1,::(@x2,@xs')))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
- Weak TRS:
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/2,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}}
+ Details:
We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
3: msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
The strictly oriented rules are moved into the weak component.
**** Step 6.b:4.b:1.a:1: NaturalMI WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
msplit#(@l) -> c_15(msplit#1#(@l))
msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
- Weak DPs:
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2#(::(@x2,@xs'),@x1) -> msplit#(::(@x1,::(@x2,@xs')))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
- Weak TRS:
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/2,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules}
+ Details:
We apply a matrix interpretation of kind constructor based matrix interpretation:
The following argument positions are considered usable:
uargs(c_15) = {1},
uargs(c_16) = {1},
uargs(c_18) = {1}
Following symbols are considered usable:
{msplit,msplit#1,msplit#2,msplit#3,#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#,mergesort#
,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#,msplit#3#}
TcT has computed the following interpretation:
p(#0) = [2]
p(#EQ) = [1]
p(#GT) = [4]
p(#LT) = [0]
p(#cklt) = [0]
p(#compare) = [0]
p(#false) = [8]
p(#less) = [2] x1 + [1] x2 + [2]
p(#neg) = [1] x1 + [8]
p(#pos) = [8]
p(#s) = [1] x1 + [2]
p(#true) = [1]
p(::) = [1] x1 + [1] x2 + [2]
p(merge) = [1]
p(merge#1) = [4] x2 + [1]
p(merge#2) = [1] x3 + [1]
p(merge#3) = [4] x3 + [1]
p(mergesort) = [1] x1 + [0]
p(mergesort#1) = [0]
p(mergesort#2) = [2] x2 + [1]
p(mergesort#3) = [1]
p(msplit) = [1] x1 + [0]
p(msplit#1) = [1] x1 + [0]
p(msplit#2) = [1] x1 + [1] x2 + [2]
p(msplit#3) = [1] x1 + [1] x2 + [1] x3 + [4]
p(nil) = [0]
p(tuple#2) = [1] x1 + [1] x2 + [0]
p(#cklt#) = [8] x1 + [1]
p(#compare#) = [1] x1 + [1] x2 + [1]
p(#less#) = [1]
p(merge#) = [1] x2 + [8]
p(merge#1#) = [1] x2 + [2]
p(merge#2#) = [8] x1 + [1] x2 + [8] x3 + [1]
p(merge#3#) = [2] x1 + [2] x2 + [1] x5 + [0]
p(mergesort#) = [4] x1 + [2]
p(mergesort#1#) = [4] x1 + [2]
p(mergesort#2#) = [4] x1 + [4] x2 + [10]
p(mergesort#3#) = [4] x1 + [2]
p(msplit#) = [4] x1 + [0]
p(msplit#1#) = [4] x1 + [0]
p(msplit#2#) = [4] x1 + [4] x2 + [8]
p(msplit#3#) = [1] x1 + [1] x2 + [1] x3 + [0]
p(c_1) = [1] x2 + [1]
p(c_2) = [8]
p(c_3) = [2] x1 + [0]
p(c_4) = [0]
p(c_5) = [1]
p(c_6) = [1]
p(c_7) = [2]
p(c_8) = [1] x1 + [8]
p(c_9) = [8] x1 + [1]
p(c_10) = [1]
p(c_11) = [1]
p(c_12) = [1] x2 + [2]
p(c_13) = [1]
p(c_14) = [1] x1 + [2] x2 + [1]
p(c_15) = [1] x1 + [0]
p(c_16) = [1] x1 + [0]
p(c_17) = [2]
p(c_18) = [1] x1 + [8]
p(c_19) = [2]
p(c_20) = [1]
p(c_21) = [1]
p(c_22) = [1]
p(c_23) = [1]
p(c_24) = [1]
p(c_25) = [1]
p(c_26) = [1]
p(c_27) = [0]
p(c_28) = [2]
p(c_29) = [1] x1 + [1]
p(c_30) = [1]
p(c_31) = [0]
p(c_32) = [1]
p(c_33) = [2] x1 + [1]
p(c_34) = [0]
p(c_35) = [1]
Following rules are strictly oriented:
msplit#2#(::(@x2,@xs'),@x1) = [4] @x1 + [4] @x2 + [4] @xs' + [16]
> [4] @xs' + [8]
= c_18(msplit#(@xs'))
Following rules are (at-least) weakly oriented:
mergesort#(@l) = [4] @l + [2]
>= [4] @l + [2]
= mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) = [4] @x1 + [4] @xs + [10]
>= [4] @x1 + [4] @xs + [10]
= mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) = [4] @x1 + [4] @x2 + [4] @xs' + [18]
>= [4] @x1 + [4] @x2 + [4] @xs' + [18]
= mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2#(::(@x2,@xs'),@x1) = [4] @x1 + [4] @x2 + [4] @xs' + [18]
>= [4] @x1 + [4] @x2 + [4] @xs' + [16]
= msplit#(::(@x1,::(@x2,@xs')))
mergesort#3#(tuple#2(@l1,@l2)) = [4] @l1 + [4] @l2 + [2]
>= [4] @l1 + [2]
= mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) = [4] @l1 + [4] @l2 + [2]
>= [4] @l2 + [2]
= mergesort#(@l2)
msplit#(@l) = [4] @l + [0]
>= [4] @l + [0]
= c_15(msplit#1#(@l))
msplit#1#(::(@x1,@xs)) = [4] @x1 + [4] @xs + [8]
>= [4] @x1 + [4] @xs + [8]
= c_16(msplit#2#(@xs,@x1))
msplit(@l) = [1] @l + [0]
>= [1] @l + [0]
= msplit#1(@l)
msplit#1(::(@x1,@xs)) = [1] @x1 + [1] @xs + [2]
>= [1] @x1 + [1] @xs + [2]
= msplit#2(@xs,@x1)
msplit#1(nil()) = [0]
>= [0]
= tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) = [1] @x1 + [1] @x2 + [1] @xs' + [4]
>= [1] @x1 + [1] @x2 + [1] @xs' + [4]
= msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) = [1] @x1 + [2]
>= [1] @x1 + [2]
= tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) = [1] @l1 + [1] @l2 + [1] @x1 + [1] @x2 + [4]
>= [1] @l1 + [1] @l2 + [1] @x1 + [1] @x2 + [4]
= tuple#2(::(@x1,@l1),::(@x2,@l2))
**** Step 6.b:4.b:1.a:2: Assumption WORST_CASE(?,O(1))
+ Considered Problem:
- Strict DPs:
msplit#(@l) -> c_15(msplit#1#(@l))
msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
- Weak DPs:
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2#(::(@x2,@xs'),@x1) -> msplit#(::(@x1,::(@x2,@xs')))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
- Weak TRS:
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/2,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
+ Details:
()
**** Step 6.b:4.b:1.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
msplit#(@l) -> c_15(msplit#1#(@l))
msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
- Weak DPs:
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2#(::(@x2,@xs'),@x1) -> msplit#(::(@x1,::(@x2,@xs')))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
- Weak TRS:
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/2,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}}
+ Details:
We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
2: msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
Consider the set of all dependency pairs
1: msplit#(@l) -> c_15(msplit#1#(@l))
2: msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
3: mergesort#(@l) -> mergesort#1#(@l)
4: mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
5: mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
6: mergesort#2#(::(@x2,@xs'),@x1) -> msplit#(::(@x1,::(@x2,@xs')))
7: mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
8: mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
9: msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
Processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}induces the complexity certificateTIME (?,O(n^1))
SPACE(?,?)on application of the dependency pairs
{2}
These cover all (indirect) predecessors of dependency pairs
{2,9}
their number of applications is equally bounded.
The dependency pairs are shifted into the weak component.
***** Step 6.b:4.b:1.b:1.a:1: NaturalMI WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
msplit#(@l) -> c_15(msplit#1#(@l))
msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
- Weak DPs:
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2#(::(@x2,@xs'),@x1) -> msplit#(::(@x1,::(@x2,@xs')))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
- Weak TRS:
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/2,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules}
+ Details:
We apply a matrix interpretation of kind constructor based matrix interpretation:
The following argument positions are considered usable:
uargs(c_15) = {1},
uargs(c_16) = {1},
uargs(c_18) = {1}
Following symbols are considered usable:
{msplit,msplit#1,msplit#2,msplit#3,#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#,mergesort#
,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#,msplit#3#}
TcT has computed the following interpretation:
p(#0) = [1]
p(#EQ) = [2]
p(#GT) = [2]
p(#LT) = [0]
p(#cklt) = [8] x1 + [0]
p(#compare) = [1] x1 + [1] x2 + [1]
p(#false) = [0]
p(#less) = [1] x1 + [1] x2 + [1]
p(#neg) = [1]
p(#pos) = [0]
p(#s) = [0]
p(#true) = [2]
p(::) = [1] x2 + [1]
p(merge) = [1] x1 + [1] x2 + [0]
p(merge#1) = [1]
p(merge#2) = [1] x2 + [1] x3 + [0]
p(merge#3) = [1] x4 + [1] x5 + [2]
p(mergesort) = [8]
p(mergesort#1) = [0]
p(mergesort#2) = [1] x1 + [1]
p(mergesort#3) = [1] x1 + [2]
p(msplit) = [1] x1 + [0]
p(msplit#1) = [1] x1 + [0]
p(msplit#2) = [1] x1 + [1]
p(msplit#3) = [1] x1 + [2]
p(nil) = [0]
p(tuple#2) = [1] x1 + [1] x2 + [0]
p(#cklt#) = [2] x1 + [1]
p(#compare#) = [1] x2 + [8]
p(#less#) = [1] x2 + [1]
p(merge#) = [1] x1 + [0]
p(merge#1#) = [1] x1 + [1] x2 + [0]
p(merge#2#) = [4] x1 + [1] x2 + [1] x3 + [1]
p(merge#3#) = [1] x1 + [2] x5 + [0]
p(mergesort#) = [8] x1 + [4]
p(mergesort#1#) = [8] x1 + [4]
p(mergesort#2#) = [8] x1 + [12]
p(mergesort#3#) = [8] x1 + [4]
p(msplit#) = [8] x1 + [4]
p(msplit#1#) = [8] x1 + [4]
p(msplit#2#) = [8] x1 + [4]
p(msplit#3#) = [1] x1 + [1] x2 + [1] x3 + [1]
p(c_1) = [1] x1 + [2] x2 + [1]
p(c_2) = [1] x1 + [1]
p(c_3) = [2] x1 + [0]
p(c_4) = [0]
p(c_5) = [1]
p(c_6) = [1]
p(c_7) = [1] x1 + [0]
p(c_8) = [1] x1 + [1]
p(c_9) = [1] x1 + [1]
p(c_10) = [1]
p(c_11) = [1]
p(c_12) = [4]
p(c_13) = [2]
p(c_14) = [2] x1 + [1] x2 + [2]
p(c_15) = [1] x1 + [0]
p(c_16) = [1] x1 + [7]
p(c_17) = [1]
p(c_18) = [1] x1 + [8]
p(c_19) = [2]
p(c_20) = [1]
p(c_21) = [1]
p(c_22) = [0]
p(c_23) = [1]
p(c_24) = [2]
p(c_25) = [1]
p(c_26) = [1]
p(c_27) = [1]
p(c_28) = [8]
p(c_29) = [8] x1 + [0]
p(c_30) = [0]
p(c_31) = [8]
p(c_32) = [1]
p(c_33) = [1]
p(c_34) = [1]
p(c_35) = [2] x1 + [1]
Following rules are strictly oriented:
msplit#1#(::(@x1,@xs)) = [8] @xs + [12]
> [8] @xs + [11]
= c_16(msplit#2#(@xs,@x1))
Following rules are (at-least) weakly oriented:
mergesort#(@l) = [8] @l + [4]
>= [8] @l + [4]
= mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) = [8] @xs + [12]
>= [8] @xs + [12]
= mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) = [8] @xs' + [20]
>= [8] @xs' + [20]
= mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2#(::(@x2,@xs'),@x1) = [8] @xs' + [20]
>= [8] @xs' + [20]
= msplit#(::(@x1,::(@x2,@xs')))
mergesort#3#(tuple#2(@l1,@l2)) = [8] @l1 + [8] @l2 + [4]
>= [8] @l1 + [4]
= mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) = [8] @l1 + [8] @l2 + [4]
>= [8] @l2 + [4]
= mergesort#(@l2)
msplit#(@l) = [8] @l + [4]
>= [8] @l + [4]
= c_15(msplit#1#(@l))
msplit#2#(::(@x2,@xs'),@x1) = [8] @xs' + [12]
>= [8] @xs' + [12]
= c_18(msplit#(@xs'))
msplit(@l) = [1] @l + [0]
>= [1] @l + [0]
= msplit#1(@l)
msplit#1(::(@x1,@xs)) = [1] @xs + [1]
>= [1] @xs + [1]
= msplit#2(@xs,@x1)
msplit#1(nil()) = [0]
>= [0]
= tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) = [1] @xs' + [2]
>= [1] @xs' + [2]
= msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) = [1]
>= [1]
= tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) = [1] @l1 + [1] @l2 + [2]
>= [1] @l1 + [1] @l2 + [2]
= tuple#2(::(@x1,@l1),::(@x2,@l2))
***** Step 6.b:4.b:1.b:1.a:2: Assumption WORST_CASE(?,O(1))
+ Considered Problem:
- Strict DPs:
msplit#(@l) -> c_15(msplit#1#(@l))
- Weak DPs:
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2#(::(@x2,@xs'),@x1) -> msplit#(::(@x1,::(@x2,@xs')))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
- Weak TRS:
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/2,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
+ Details:
()
***** Step 6.b:4.b:1.b:1.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
msplit#(@l) -> c_15(msplit#1#(@l))
- Weak DPs:
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2#(::(@x2,@xs'),@x1) -> msplit#(::(@x1,::(@x2,@xs')))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
- Weak TRS:
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/2,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}}
+ Details:
We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
1: msplit#(@l) -> c_15(msplit#1#(@l))
Consider the set of all dependency pairs
1: msplit#(@l) -> c_15(msplit#1#(@l))
2: mergesort#(@l) -> mergesort#1#(@l)
3: mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
4: mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
5: mergesort#2#(::(@x2,@xs'),@x1) -> msplit#(::(@x1,::(@x2,@xs')))
6: mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
7: mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
8: msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
9: msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
Processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}induces the complexity certificateTIME (?,O(n^1))
SPACE(?,?)on application of the dependency pairs
{1}
These cover all (indirect) predecessors of dependency pairs
{1,8,9}
their number of applications is equally bounded.
The dependency pairs are shifted into the weak component.
****** Step 6.b:4.b:1.b:1.b:1.a:1: NaturalMI WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
msplit#(@l) -> c_15(msplit#1#(@l))
- Weak DPs:
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2#(::(@x2,@xs'),@x1) -> msplit#(::(@x1,::(@x2,@xs')))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
- Weak TRS:
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/2,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just first alternative for predecessorEstimation on any intersect of rules of CDG leaf and strict-rules}
+ Details:
We apply a matrix interpretation of kind constructor based matrix interpretation:
The following argument positions are considered usable:
uargs(c_15) = {1},
uargs(c_16) = {1},
uargs(c_18) = {1}
Following symbols are considered usable:
{msplit,msplit#1,msplit#2,msplit#3,#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#,mergesort#
,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#,msplit#3#}
TcT has computed the following interpretation:
p(#0) = [1]
p(#EQ) = [0]
p(#GT) = [1]
p(#LT) = [0]
p(#cklt) = [1]
p(#compare) = [0]
p(#false) = [1]
p(#less) = [1] x1 + [1]
p(#neg) = [0]
p(#pos) = [1] x1 + [4]
p(#s) = [1] x1 + [4]
p(#true) = [0]
p(::) = [1] x2 + [1]
p(merge) = [1] x1 + [4]
p(merge#1) = [8] x1 + [2] x2 + [2]
p(merge#2) = [1] x1 + [1] x2 + [0]
p(merge#3) = [4] x3 + [8] x4 + [1]
p(mergesort) = [4] x1 + [2]
p(mergesort#1) = [8] x1 + [1]
p(mergesort#2) = [1] x1 + [2] x2 + [0]
p(mergesort#3) = [1] x1 + [8]
p(msplit) = [1] x1 + [0]
p(msplit#1) = [1] x1 + [0]
p(msplit#2) = [1] x1 + [1]
p(msplit#3) = [1] x1 + [2]
p(nil) = [0]
p(tuple#2) = [1] x1 + [1] x2 + [0]
p(#cklt#) = [1] x1 + [1]
p(#compare#) = [1] x1 + [1] x2 + [1]
p(#less#) = [2] x1 + [4] x2 + [1]
p(merge#) = [2] x2 + [1]
p(merge#1#) = [1] x1 + [0]
p(merge#2#) = [1] x1 + [1] x2 + [1] x3 + [1]
p(merge#3#) = [1] x1 + [1]
p(mergesort#) = [4] x1 + [10]
p(mergesort#1#) = [4] x1 + [10]
p(mergesort#2#) = [4] x1 + [14]
p(mergesort#3#) = [4] x1 + [10]
p(msplit#) = [4] x1 + [4]
p(msplit#1#) = [4] x1 + [0]
p(msplit#2#) = [4] x1 + [0]
p(msplit#3#) = [8] x1 + [2] x2 + [1]
p(c_1) = [2]
p(c_2) = [1] x1 + [1]
p(c_3) = [1]
p(c_4) = [0]
p(c_5) = [2]
p(c_6) = [1]
p(c_7) = [1]
p(c_8) = [2]
p(c_9) = [1] x1 + [1]
p(c_10) = [4] x1 + [2]
p(c_11) = [2]
p(c_12) = [1] x1 + [1] x2 + [2]
p(c_13) = [1]
p(c_14) = [1] x1 + [0]
p(c_15) = [1] x1 + [3]
p(c_16) = [1] x1 + [4]
p(c_17) = [2]
p(c_18) = [1] x1 + [0]
p(c_19) = [1]
p(c_20) = [2]
p(c_21) = [0]
p(c_22) = [1]
p(c_23) = [1]
p(c_24) = [0]
p(c_25) = [0]
p(c_26) = [0]
p(c_27) = [0]
p(c_28) = [2]
p(c_29) = [0]
p(c_30) = [1]
p(c_31) = [0]
p(c_32) = [1]
p(c_33) = [1]
p(c_34) = [2]
p(c_35) = [0]
Following rules are strictly oriented:
msplit#(@l) = [4] @l + [4]
> [4] @l + [3]
= c_15(msplit#1#(@l))
Following rules are (at-least) weakly oriented:
mergesort#(@l) = [4] @l + [10]
>= [4] @l + [10]
= mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) = [4] @xs + [14]
>= [4] @xs + [14]
= mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) = [4] @xs' + [18]
>= [4] @xs' + [18]
= mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2#(::(@x2,@xs'),@x1) = [4] @xs' + [18]
>= [4] @xs' + [12]
= msplit#(::(@x1,::(@x2,@xs')))
mergesort#3#(tuple#2(@l1,@l2)) = [4] @l1 + [4] @l2 + [10]
>= [4] @l1 + [10]
= mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) = [4] @l1 + [4] @l2 + [10]
>= [4] @l2 + [10]
= mergesort#(@l2)
msplit#1#(::(@x1,@xs)) = [4] @xs + [4]
>= [4] @xs + [4]
= c_16(msplit#2#(@xs,@x1))
msplit#2#(::(@x2,@xs'),@x1) = [4] @xs' + [4]
>= [4] @xs' + [4]
= c_18(msplit#(@xs'))
msplit(@l) = [1] @l + [0]
>= [1] @l + [0]
= msplit#1(@l)
msplit#1(::(@x1,@xs)) = [1] @xs + [1]
>= [1] @xs + [1]
= msplit#2(@xs,@x1)
msplit#1(nil()) = [0]
>= [0]
= tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) = [1] @xs' + [2]
>= [1] @xs' + [2]
= msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) = [1]
>= [1]
= tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) = [1] @l1 + [1] @l2 + [2]
>= [1] @l1 + [1] @l2 + [2]
= tuple#2(::(@x1,@l1),::(@x2,@l2))
****** Step 6.b:4.b:1.b:1.b:1.a:2: Assumption WORST_CASE(?,O(1))
+ Considered Problem:
- Weak DPs:
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2#(::(@x2,@xs'),@x1) -> msplit#(::(@x1,::(@x2,@xs')))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
msplit#(@l) -> c_15(msplit#1#(@l))
msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
- Weak TRS:
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/2,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
+ Details:
()
****** Step 6.b:4.b:1.b:1.b:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1))
+ Considered Problem:
- Weak DPs:
mergesort#(@l) -> mergesort#1#(@l)
mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
mergesort#2#(::(@x2,@xs'),@x1) -> msplit#(::(@x1,::(@x2,@xs')))
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
msplit#(@l) -> c_15(msplit#1#(@l))
msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
- Weak TRS:
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/2,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
RemoveWeakSuffixes
+ Details:
Consider the dependency graph
1:W:mergesort#(@l) -> mergesort#1#(@l)
-->_1 mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1):2
2:W:mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
-->_1 mergesort#2#(::(@x2,@xs'),@x1) -> msplit#(::(@x1,::(@x2,@xs'))):4
-->_1 mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs')))):3
3:W:mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
-->_1 mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2):6
-->_1 mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1):5
4:W:mergesort#2#(::(@x2,@xs'),@x1) -> msplit#(::(@x1,::(@x2,@xs')))
-->_1 msplit#(@l) -> c_15(msplit#1#(@l)):7
5:W:mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
-->_1 mergesort#(@l) -> mergesort#1#(@l):1
6:W:mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
-->_1 mergesort#(@l) -> mergesort#1#(@l):1
7:W:msplit#(@l) -> c_15(msplit#1#(@l))
-->_1 msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1)):8
8:W:msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
-->_1 msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs')):9
9:W:msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
-->_1 msplit#(@l) -> c_15(msplit#1#(@l)):7
The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
1: mergesort#(@l) -> mergesort#1#(@l)
6: mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l2)
3: mergesort#2#(::(@x2,@xs'),@x1) -> mergesort#3#(msplit(::(@x1,::(@x2,@xs'))))
2: mergesort#1#(::(@x1,@xs)) -> mergesort#2#(@xs,@x1)
5: mergesort#3#(tuple#2(@l1,@l2)) -> mergesort#(@l1)
4: mergesort#2#(::(@x2,@xs'),@x1) -> msplit#(::(@x1,::(@x2,@xs')))
7: msplit#(@l) -> c_15(msplit#1#(@l))
9: msplit#2#(::(@x2,@xs'),@x1) -> c_18(msplit#(@xs'))
8: msplit#1#(::(@x1,@xs)) -> c_16(msplit#2#(@xs,@x1))
****** Step 6.b:4.b:1.b:1.b:1.b:2: EmptyProcessor WORST_CASE(?,O(1))
+ Considered Problem:
- Weak TRS:
msplit(@l) -> msplit#1(@l)
msplit#1(::(@x1,@xs)) -> msplit#2(@xs,@x1)
msplit#1(nil()) -> tuple#2(nil(),nil())
msplit#2(::(@x2,@xs'),@x1) -> msplit#3(msplit(@xs'),@x1,@x2)
msplit#2(nil(),@x1) -> tuple#2(::(@x1,nil()),nil())
msplit#3(tuple#2(@l1,@l2),@x1,@x2) -> tuple#2(::(@x1,@l1),::(@x2,@l2))
- Signature:
{#cklt/1,#compare/2,#less/2,merge/2,merge#1/2,merge#2/3,merge#3/5,mergesort/1,mergesort#1/1,mergesort#2/2
,mergesort#3/1,msplit/1,msplit#1/1,msplit#2/2,msplit#3/3,#cklt#/1,#compare#/2,#less#/2,merge#/2,merge#1#/2
,merge#2#/3,merge#3#/5,mergesort#/1,mergesort#1#/1,mergesort#2#/2,mergesort#3#/1,msplit#/1,msplit#1#/1
,msplit#2#/2,msplit#3#/3} / {#0/0,#EQ/0,#GT/0,#LT/0,#false/0,#neg/1,#pos/1,#s/1,#true/0,::/2,nil/0,tuple#2/2
,c_1/2,c_2/1,c_3/1,c_4/0,c_5/1,c_6/0,c_7/1,c_8/1,c_9/1,c_10/1,c_11/0,c_12/2,c_13/0,c_14/2,c_15/1,c_16/1
,c_17/0,c_18/1,c_19/0,c_20/0,c_21/0,c_22/0,c_23/0,c_24/0,c_25/0,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/0
,c_32/0,c_33/1,c_34/0,c_35/1}
- Obligation:
innermost runtime complexity wrt. defined symbols {#cklt#,#compare#,#less#,merge#,merge#1#,merge#2#,merge#3#
,mergesort#,mergesort#1#,mergesort#2#,mergesort#3#,msplit#,msplit#1#,msplit#2#
,msplit#3#} and constructors {#0,#EQ,#GT,#LT,#false,#neg,#pos,#s,#true,::,nil,tuple#2}
+ Applied Processor:
EmptyProcessor
+ Details:
The problem is already closed. The intended complexity is O(1).
WORST_CASE(?,O(n^2))