* Step 1: Sum WORST_CASE(Omega(n^1),O(n^4))
+ Considered Problem:
- Strict TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
and(x,false()) -> false()
and(x,true()) -> x
bs(l(x)) -> true()
bs(n(x,y,z)) -> and(and(ge(x,max(y)),ge(min(z),x)),and(bs(y),bs(z)))
ge(x,#()) -> true()
ge(#(),0(x)) -> ge(#(),x)
ge(#(),1(x)) -> false()
ge(0(x),0(y)) -> ge(x,y)
ge(0(x),1(y)) -> not(ge(y,x))
ge(1(x),0(y)) -> ge(x,y)
ge(1(x),1(y)) -> ge(x,y)
if(false(),x,y) -> y
if(true(),x,y) -> x
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
not(false()) -> true()
not(true()) -> false()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
val(l(x)) -> x
val(n(x,y,z)) -> x
wb(l(x)) -> true()
wb(n(x,y,z)) -> and(if(ge(size(y),size(z)),ge(1(#()),-(size(y),size(z))),ge(1(#()),-(size(z),size(y))))
,and(wb(y),wb(z)))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1} / {#/0,1/1,false/0,l/1,n/3,true/0}
- Obligation:
innermost runtime complexity wrt. defined symbols {+,-,0,and,bs,ge,if,max,min,not,size,val
,wb} and constructors {#,1,false,l,n,true}
+ Applied Processor:
Sum {left = someStrategy, right = someStrategy}
+ Details:
()
** Step 1.a:1: DecreasingLoops WORST_CASE(Omega(n^1),?)
+ Considered Problem:
- Strict TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
and(x,false()) -> false()
and(x,true()) -> x
bs(l(x)) -> true()
bs(n(x,y,z)) -> and(and(ge(x,max(y)),ge(min(z),x)),and(bs(y),bs(z)))
ge(x,#()) -> true()
ge(#(),0(x)) -> ge(#(),x)
ge(#(),1(x)) -> false()
ge(0(x),0(y)) -> ge(x,y)
ge(0(x),1(y)) -> not(ge(y,x))
ge(1(x),0(y)) -> ge(x,y)
ge(1(x),1(y)) -> ge(x,y)
if(false(),x,y) -> y
if(true(),x,y) -> x
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
not(false()) -> true()
not(true()) -> false()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
val(l(x)) -> x
val(n(x,y,z)) -> x
wb(l(x)) -> true()
wb(n(x,y,z)) -> and(if(ge(size(y),size(z)),ge(1(#()),-(size(y),size(z))),ge(1(#()),-(size(z),size(y))))
,and(wb(y),wb(z)))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1} / {#/0,1/1,false/0,l/1,n/3,true/0}
- Obligation:
innermost runtime complexity wrt. defined symbols {+,-,0,and,bs,ge,if,max,min,not,size,val
,wb} and constructors {#,1,false,l,n,true}
+ Applied Processor:
DecreasingLoops {bound = AnyLoop, narrow = 10}
+ Details:
The system has following decreasing Loops:
+(x,y){x -> 1(x),y -> 1(y)} =
+(1(x),1(y)) ->^+ 0(+(+(x,y),1(#())))
= C[+(x,y) = +(x,y){}]
** Step 1.b:1: DependencyPairs WORST_CASE(?,O(n^4))
+ Considered Problem:
- Strict TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
and(x,false()) -> false()
and(x,true()) -> x
bs(l(x)) -> true()
bs(n(x,y,z)) -> and(and(ge(x,max(y)),ge(min(z),x)),and(bs(y),bs(z)))
ge(x,#()) -> true()
ge(#(),0(x)) -> ge(#(),x)
ge(#(),1(x)) -> false()
ge(0(x),0(y)) -> ge(x,y)
ge(0(x),1(y)) -> not(ge(y,x))
ge(1(x),0(y)) -> ge(x,y)
ge(1(x),1(y)) -> ge(x,y)
if(false(),x,y) -> y
if(true(),x,y) -> x
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
not(false()) -> true()
not(true()) -> false()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
val(l(x)) -> x
val(n(x,y,z)) -> x
wb(l(x)) -> true()
wb(n(x,y,z)) -> and(if(ge(size(y),size(z)),ge(1(#()),-(size(y),size(z))),ge(1(#()),-(size(z),size(y))))
,and(wb(y),wb(z)))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1} / {#/0,1/1,false/0,l/1,n/3,true/0}
- Obligation:
innermost runtime complexity wrt. defined symbols {+,-,0,and,bs,ge,if,max,min,not,size,val
,wb} and constructors {#,1,false,l,n,true}
+ Applied Processor:
DependencyPairs {dpKind_ = DT}
+ Details:
We add the following dependency tuples:
Strict DPs
+#(x,#()) -> c_1()
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(#(),x) -> c_3()
+#(0(x),0(y)) -> c_4(0#(+(x,y)),+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y))
-#(x,#()) -> c_8()
-#(#(),x) -> c_9()
-#(0(x),0(y)) -> c_10(0#(-(x,y)),-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(0#(-(x,y)),-#(x,y))
0#(#()) -> c_14()
and#(x,false()) -> c_15()
and#(x,true()) -> c_16()
bs#(l(x)) -> c_17()
bs#(n(x,y,z)) -> c_18(and#(and(ge(x,max(y)),ge(min(z),x)),and(bs(y),bs(z)))
,and#(ge(x,max(y)),ge(min(z),x))
,ge#(x,max(y))
,max#(y)
,ge#(min(z),x)
,min#(z)
,and#(bs(y),bs(z))
,bs#(y)
,bs#(z))
ge#(x,#()) -> c_19()
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(#(),1(x)) -> c_21()
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(not#(ge(y,x)),ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
if#(false(),x,y) -> c_26()
if#(true(),x,y) -> c_27()
max#(l(x)) -> c_28()
max#(n(x,y,z)) -> c_29(max#(z))
min#(l(x)) -> c_30()
min#(n(x,y,z)) -> c_31(min#(y))
not#(false()) -> c_32()
not#(true()) -> c_33()
size#(l(x)) -> c_34()
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
val#(l(x)) -> c_36()
val#(n(x,y,z)) -> c_37()
wb#(l(x)) -> c_38()
wb#(n(x,y,z)) -> c_39(and#(if(ge(size(y),size(z))
,ge(1(#()),-(size(y),size(z)))
,ge(1(#()),-(size(z),size(y))))
,and(wb(y),wb(z)))
,if#(ge(size(y),size(z)),ge(1(#()),-(size(y),size(z))),ge(1(#()),-(size(z),size(y))))
,ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,and#(wb(y),wb(z))
,wb#(y)
,wb#(z))
Weak DPs
and mark the set of starting terms.
** Step 1.b:2: UsableRules WORST_CASE(?,O(n^4))
+ Considered Problem:
- Strict DPs:
+#(x,#()) -> c_1()
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(#(),x) -> c_3()
+#(0(x),0(y)) -> c_4(0#(+(x,y)),+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y))
-#(x,#()) -> c_8()
-#(#(),x) -> c_9()
-#(0(x),0(y)) -> c_10(0#(-(x,y)),-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(0#(-(x,y)),-#(x,y))
0#(#()) -> c_14()
and#(x,false()) -> c_15()
and#(x,true()) -> c_16()
bs#(l(x)) -> c_17()
bs#(n(x,y,z)) -> c_18(and#(and(ge(x,max(y)),ge(min(z),x)),and(bs(y),bs(z)))
,and#(ge(x,max(y)),ge(min(z),x))
,ge#(x,max(y))
,max#(y)
,ge#(min(z),x)
,min#(z)
,and#(bs(y),bs(z))
,bs#(y)
,bs#(z))
ge#(x,#()) -> c_19()
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(#(),1(x)) -> c_21()
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(not#(ge(y,x)),ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
if#(false(),x,y) -> c_26()
if#(true(),x,y) -> c_27()
max#(l(x)) -> c_28()
max#(n(x,y,z)) -> c_29(max#(z))
min#(l(x)) -> c_30()
min#(n(x,y,z)) -> c_31(min#(y))
not#(false()) -> c_32()
not#(true()) -> c_33()
size#(l(x)) -> c_34()
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
val#(l(x)) -> c_36()
val#(n(x,y,z)) -> c_37()
wb#(l(x)) -> c_38()
wb#(n(x,y,z)) -> c_39(and#(if(ge(size(y),size(z))
,ge(1(#()),-(size(y),size(z)))
,ge(1(#()),-(size(z),size(y))))
,and(wb(y),wb(z)))
,if#(ge(size(y),size(z)),ge(1(#()),-(size(y),size(z))),ge(1(#()),-(size(z),size(y))))
,ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,and#(wb(y),wb(z))
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
and(x,false()) -> false()
and(x,true()) -> x
bs(l(x)) -> true()
bs(n(x,y,z)) -> and(and(ge(x,max(y)),ge(min(z),x)),and(bs(y),bs(z)))
ge(x,#()) -> true()
ge(#(),0(x)) -> ge(#(),x)
ge(#(),1(x)) -> false()
ge(0(x),0(y)) -> ge(x,y)
ge(0(x),1(y)) -> not(ge(y,x))
ge(1(x),0(y)) -> ge(x,y)
ge(1(x),1(y)) -> ge(x,y)
if(false(),x,y) -> y
if(true(),x,y) -> x
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
not(false()) -> true()
not(true()) -> false()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
val(l(x)) -> x
val(n(x,y,z)) -> x
wb(l(x)) -> true()
wb(n(x,y,z)) -> and(if(ge(size(y),size(z)),ge(1(#()),-(size(y),size(z))),ge(1(#()),-(size(z),size(y))))
,and(wb(y),wb(z)))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/2
,c_5/1,c_6/1,c_7/3,c_8/0,c_9/0,c_10/2,c_11/2,c_12/1,c_13/2,c_14/0,c_15/0,c_16/0,c_17/0,c_18/9,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/2,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/16}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
UsableRules
+ Details:
We replace rewrite rules by usable rules:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
and(x,false()) -> false()
and(x,true()) -> x
bs(l(x)) -> true()
bs(n(x,y,z)) -> and(and(ge(x,max(y)),ge(min(z),x)),and(bs(y),bs(z)))
ge(x,#()) -> true()
ge(#(),0(x)) -> ge(#(),x)
ge(#(),1(x)) -> false()
ge(0(x),0(y)) -> ge(x,y)
ge(0(x),1(y)) -> not(ge(y,x))
ge(1(x),0(y)) -> ge(x,y)
ge(1(x),1(y)) -> ge(x,y)
if(false(),x,y) -> y
if(true(),x,y) -> x
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
not(false()) -> true()
not(true()) -> false()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
wb(l(x)) -> true()
wb(n(x,y,z)) -> and(if(ge(size(y),size(z)),ge(1(#()),-(size(y),size(z))),ge(1(#()),-(size(z),size(y))))
,and(wb(y),wb(z)))
+#(x,#()) -> c_1()
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(#(),x) -> c_3()
+#(0(x),0(y)) -> c_4(0#(+(x,y)),+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y))
-#(x,#()) -> c_8()
-#(#(),x) -> c_9()
-#(0(x),0(y)) -> c_10(0#(-(x,y)),-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(0#(-(x,y)),-#(x,y))
0#(#()) -> c_14()
and#(x,false()) -> c_15()
and#(x,true()) -> c_16()
bs#(l(x)) -> c_17()
bs#(n(x,y,z)) -> c_18(and#(and(ge(x,max(y)),ge(min(z),x)),and(bs(y),bs(z)))
,and#(ge(x,max(y)),ge(min(z),x))
,ge#(x,max(y))
,max#(y)
,ge#(min(z),x)
,min#(z)
,and#(bs(y),bs(z))
,bs#(y)
,bs#(z))
ge#(x,#()) -> c_19()
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(#(),1(x)) -> c_21()
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(not#(ge(y,x)),ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
if#(false(),x,y) -> c_26()
if#(true(),x,y) -> c_27()
max#(l(x)) -> c_28()
max#(n(x,y,z)) -> c_29(max#(z))
min#(l(x)) -> c_30()
min#(n(x,y,z)) -> c_31(min#(y))
not#(false()) -> c_32()
not#(true()) -> c_33()
size#(l(x)) -> c_34()
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
val#(l(x)) -> c_36()
val#(n(x,y,z)) -> c_37()
wb#(l(x)) -> c_38()
wb#(n(x,y,z)) -> c_39(and#(if(ge(size(y),size(z))
,ge(1(#()),-(size(y),size(z)))
,ge(1(#()),-(size(z),size(y))))
,and(wb(y),wb(z)))
,if#(ge(size(y),size(z)),ge(1(#()),-(size(y),size(z))),ge(1(#()),-(size(z),size(y))))
,ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,and#(wb(y),wb(z))
,wb#(y)
,wb#(z))
** Step 1.b:3: PredecessorEstimation WORST_CASE(?,O(n^4))
+ Considered Problem:
- Strict DPs:
+#(x,#()) -> c_1()
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(#(),x) -> c_3()
+#(0(x),0(y)) -> c_4(0#(+(x,y)),+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y))
-#(x,#()) -> c_8()
-#(#(),x) -> c_9()
-#(0(x),0(y)) -> c_10(0#(-(x,y)),-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(0#(-(x,y)),-#(x,y))
0#(#()) -> c_14()
and#(x,false()) -> c_15()
and#(x,true()) -> c_16()
bs#(l(x)) -> c_17()
bs#(n(x,y,z)) -> c_18(and#(and(ge(x,max(y)),ge(min(z),x)),and(bs(y),bs(z)))
,and#(ge(x,max(y)),ge(min(z),x))
,ge#(x,max(y))
,max#(y)
,ge#(min(z),x)
,min#(z)
,and#(bs(y),bs(z))
,bs#(y)
,bs#(z))
ge#(x,#()) -> c_19()
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(#(),1(x)) -> c_21()
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(not#(ge(y,x)),ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
if#(false(),x,y) -> c_26()
if#(true(),x,y) -> c_27()
max#(l(x)) -> c_28()
max#(n(x,y,z)) -> c_29(max#(z))
min#(l(x)) -> c_30()
min#(n(x,y,z)) -> c_31(min#(y))
not#(false()) -> c_32()
not#(true()) -> c_33()
size#(l(x)) -> c_34()
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
val#(l(x)) -> c_36()
val#(n(x,y,z)) -> c_37()
wb#(l(x)) -> c_38()
wb#(n(x,y,z)) -> c_39(and#(if(ge(size(y),size(z))
,ge(1(#()),-(size(y),size(z)))
,ge(1(#()),-(size(z),size(y))))
,and(wb(y),wb(z)))
,if#(ge(size(y),size(z)),ge(1(#()),-(size(y),size(z))),ge(1(#()),-(size(z),size(y))))
,ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,and#(wb(y),wb(z))
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
and(x,false()) -> false()
and(x,true()) -> x
bs(l(x)) -> true()
bs(n(x,y,z)) -> and(and(ge(x,max(y)),ge(min(z),x)),and(bs(y),bs(z)))
ge(x,#()) -> true()
ge(#(),0(x)) -> ge(#(),x)
ge(#(),1(x)) -> false()
ge(0(x),0(y)) -> ge(x,y)
ge(0(x),1(y)) -> not(ge(y,x))
ge(1(x),0(y)) -> ge(x,y)
ge(1(x),1(y)) -> ge(x,y)
if(false(),x,y) -> y
if(true(),x,y) -> x
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
not(false()) -> true()
not(true()) -> false()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
wb(l(x)) -> true()
wb(n(x,y,z)) -> and(if(ge(size(y),size(z)),ge(1(#()),-(size(y),size(z))),ge(1(#()),-(size(z),size(y))))
,and(wb(y),wb(z)))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/2
,c_5/1,c_6/1,c_7/3,c_8/0,c_9/0,c_10/2,c_11/2,c_12/1,c_13/2,c_14/0,c_15/0,c_16/0,c_17/0,c_18/9,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/2,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/16}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
PredecessorEstimation {onSelection = all simple predecessor estimation selector}
+ Details:
We estimate the number of application of
{1,3,8,9,14,15,16,17,19,21,26,27,28,30,32,33,34,36,37,38}
by application of
Pre({1,3,8,9,14,15,16,17,19,21,26,27,28,30,32,33,34,36,37,38}) = {2,4,5,6,7,10,11,12,13,18,20,22,23,24,25
,29,31,35,39}.
Here rules are labelled as follows:
1: +#(x,#()) -> c_1()
2: +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
3: +#(#(),x) -> c_3()
4: +#(0(x),0(y)) -> c_4(0#(+(x,y)),+#(x,y))
5: +#(0(x),1(y)) -> c_5(+#(x,y))
6: +#(1(x),0(y)) -> c_6(+#(x,y))
7: +#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y))
8: -#(x,#()) -> c_8()
9: -#(#(),x) -> c_9()
10: -#(0(x),0(y)) -> c_10(0#(-(x,y)),-#(x,y))
11: -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
12: -#(1(x),0(y)) -> c_12(-#(x,y))
13: -#(1(x),1(y)) -> c_13(0#(-(x,y)),-#(x,y))
14: 0#(#()) -> c_14()
15: and#(x,false()) -> c_15()
16: and#(x,true()) -> c_16()
17: bs#(l(x)) -> c_17()
18: bs#(n(x,y,z)) -> c_18(and#(and(ge(x,max(y)),ge(min(z),x)),and(bs(y),bs(z)))
,and#(ge(x,max(y)),ge(min(z),x))
,ge#(x,max(y))
,max#(y)
,ge#(min(z),x)
,min#(z)
,and#(bs(y),bs(z))
,bs#(y)
,bs#(z))
19: ge#(x,#()) -> c_19()
20: ge#(#(),0(x)) -> c_20(ge#(#(),x))
21: ge#(#(),1(x)) -> c_21()
22: ge#(0(x),0(y)) -> c_22(ge#(x,y))
23: ge#(0(x),1(y)) -> c_23(not#(ge(y,x)),ge#(y,x))
24: ge#(1(x),0(y)) -> c_24(ge#(x,y))
25: ge#(1(x),1(y)) -> c_25(ge#(x,y))
26: if#(false(),x,y) -> c_26()
27: if#(true(),x,y) -> c_27()
28: max#(l(x)) -> c_28()
29: max#(n(x,y,z)) -> c_29(max#(z))
30: min#(l(x)) -> c_30()
31: min#(n(x,y,z)) -> c_31(min#(y))
32: not#(false()) -> c_32()
33: not#(true()) -> c_33()
34: size#(l(x)) -> c_34()
35: size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
36: val#(l(x)) -> c_36()
37: val#(n(x,y,z)) -> c_37()
38: wb#(l(x)) -> c_38()
39: wb#(n(x,y,z)) -> c_39(and#(if(ge(size(y),size(z))
,ge(1(#()),-(size(y),size(z)))
,ge(1(#()),-(size(z),size(y))))
,and(wb(y),wb(z)))
,if#(ge(size(y),size(z)),ge(1(#()),-(size(y),size(z))),ge(1(#()),-(size(z),size(y))))
,ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,and#(wb(y),wb(z))
,wb#(y)
,wb#(z))
** Step 1.b:4: RemoveWeakSuffixes WORST_CASE(?,O(n^4))
+ Considered Problem:
- Strict DPs:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(0#(+(x,y)),+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y))
-#(0(x),0(y)) -> c_10(0#(-(x,y)),-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(0#(-(x,y)),-#(x,y))
bs#(n(x,y,z)) -> c_18(and#(and(ge(x,max(y)),ge(min(z),x)),and(bs(y),bs(z)))
,and#(ge(x,max(y)),ge(min(z),x))
,ge#(x,max(y))
,max#(y)
,ge#(min(z),x)
,min#(z)
,and#(bs(y),bs(z))
,bs#(y)
,bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(not#(ge(y,x)),ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
min#(n(x,y,z)) -> c_31(min#(y))
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(and#(if(ge(size(y),size(z))
,ge(1(#()),-(size(y),size(z)))
,ge(1(#()),-(size(z),size(y))))
,and(wb(y),wb(z)))
,if#(ge(size(y),size(z)),ge(1(#()),-(size(y),size(z))),ge(1(#()),-(size(z),size(y))))
,ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,and#(wb(y),wb(z))
,wb#(y)
,wb#(z))
- Weak DPs:
+#(x,#()) -> c_1()
+#(#(),x) -> c_3()
-#(x,#()) -> c_8()
-#(#(),x) -> c_9()
0#(#()) -> c_14()
and#(x,false()) -> c_15()
and#(x,true()) -> c_16()
bs#(l(x)) -> c_17()
ge#(x,#()) -> c_19()
ge#(#(),1(x)) -> c_21()
if#(false(),x,y) -> c_26()
if#(true(),x,y) -> c_27()
max#(l(x)) -> c_28()
min#(l(x)) -> c_30()
not#(false()) -> c_32()
not#(true()) -> c_33()
size#(l(x)) -> c_34()
val#(l(x)) -> c_36()
val#(n(x,y,z)) -> c_37()
wb#(l(x)) -> c_38()
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
and(x,false()) -> false()
and(x,true()) -> x
bs(l(x)) -> true()
bs(n(x,y,z)) -> and(and(ge(x,max(y)),ge(min(z),x)),and(bs(y),bs(z)))
ge(x,#()) -> true()
ge(#(),0(x)) -> ge(#(),x)
ge(#(),1(x)) -> false()
ge(0(x),0(y)) -> ge(x,y)
ge(0(x),1(y)) -> not(ge(y,x))
ge(1(x),0(y)) -> ge(x,y)
ge(1(x),1(y)) -> ge(x,y)
if(false(),x,y) -> y
if(true(),x,y) -> x
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
not(false()) -> true()
not(true()) -> false()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
wb(l(x)) -> true()
wb(n(x,y,z)) -> and(if(ge(size(y),size(z)),ge(1(#()),-(size(y),size(z))),ge(1(#()),-(size(z),size(y))))
,and(wb(y),wb(z)))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/2
,c_5/1,c_6/1,c_7/3,c_8/0,c_9/0,c_10/2,c_11/2,c_12/1,c_13/2,c_14/0,c_15/0,c_16/0,c_17/0,c_18/9,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/2,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/16}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
RemoveWeakSuffixes
+ Details:
Consider the dependency graph
1:S:+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
-->_2 +#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y)):5
-->_2 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_1 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_2 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_2 +#(0(x),0(y)) -> c_4(0#(+(x,y)),+#(x,y)):2
-->_1 +#(0(x),0(y)) -> c_4(0#(+(x,y)),+#(x,y)):2
-->_2 +#(#(),x) -> c_3():21
-->_1 +#(#(),x) -> c_3():21
-->_2 +#(x,#()) -> c_1():20
-->_1 +#(x,#()) -> c_1():20
-->_2 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
-->_1 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
2:S:+#(0(x),0(y)) -> c_4(0#(+(x,y)),+#(x,y))
-->_2 +#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y)):5
-->_2 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_2 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 0#(#()) -> c_14():24
-->_2 +#(#(),x) -> c_3():21
-->_2 +#(x,#()) -> c_1():20
-->_2 +#(0(x),0(y)) -> c_4(0#(+(x,y)),+#(x,y)):2
-->_2 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
3:S:+#(0(x),1(y)) -> c_5(+#(x,y))
-->_1 +#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_1 +#(#(),x) -> c_3():21
-->_1 +#(x,#()) -> c_1():20
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 +#(0(x),0(y)) -> c_4(0#(+(x,y)),+#(x,y)):2
-->_1 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
4:S:+#(1(x),0(y)) -> c_6(+#(x,y))
-->_1 +#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(#(),x) -> c_3():21
-->_1 +#(x,#()) -> c_1():20
-->_1 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 +#(0(x),0(y)) -> c_4(0#(+(x,y)),+#(x,y)):2
-->_1 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
5:S:+#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y))
-->_1 0#(#()) -> c_14():24
-->_3 +#(#(),x) -> c_3():21
-->_2 +#(#(),x) -> c_3():21
-->_3 +#(x,#()) -> c_1():20
-->_3 +#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y)):5
-->_2 +#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y)):5
-->_3 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_3 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_2 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_3 +#(0(x),0(y)) -> c_4(0#(+(x,y)),+#(x,y)):2
-->_3 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
6:S:-#(0(x),0(y)) -> c_10(0#(-(x,y)),-#(x,y))
-->_2 -#(1(x),1(y)) -> c_13(0#(-(x,y)),-#(x,y)):9
-->_2 -#(1(x),0(y)) -> c_12(-#(x,y)):8
-->_2 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):7
-->_1 0#(#()) -> c_14():24
-->_2 -#(#(),x) -> c_9():23
-->_2 -#(x,#()) -> c_8():22
-->_2 -#(0(x),0(y)) -> c_10(0#(-(x,y)),-#(x,y)):6
7:S:-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-->_2 -#(1(x),1(y)) -> c_13(0#(-(x,y)),-#(x,y)):9
-->_1 -#(1(x),1(y)) -> c_13(0#(-(x,y)),-#(x,y)):9
-->_2 -#(1(x),0(y)) -> c_12(-#(x,y)):8
-->_2 -#(#(),x) -> c_9():23
-->_1 -#(#(),x) -> c_9():23
-->_2 -#(x,#()) -> c_8():22
-->_2 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):7
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):7
-->_2 -#(0(x),0(y)) -> c_10(0#(-(x,y)),-#(x,y)):6
8:S:-#(1(x),0(y)) -> c_12(-#(x,y))
-->_1 -#(1(x),1(y)) -> c_13(0#(-(x,y)),-#(x,y)):9
-->_1 -#(#(),x) -> c_9():23
-->_1 -#(x,#()) -> c_8():22
-->_1 -#(1(x),0(y)) -> c_12(-#(x,y)):8
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):7
-->_1 -#(0(x),0(y)) -> c_10(0#(-(x,y)),-#(x,y)):6
9:S:-#(1(x),1(y)) -> c_13(0#(-(x,y)),-#(x,y))
-->_1 0#(#()) -> c_14():24
-->_2 -#(#(),x) -> c_9():23
-->_2 -#(x,#()) -> c_8():22
-->_2 -#(1(x),1(y)) -> c_13(0#(-(x,y)),-#(x,y)):9
-->_2 -#(1(x),0(y)) -> c_12(-#(x,y)):8
-->_2 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):7
-->_2 -#(0(x),0(y)) -> c_10(0#(-(x,y)),-#(x,y)):6
10:S:bs#(n(x,y,z)) -> c_18(and#(and(ge(x,max(y)),ge(min(z),x)),and(bs(y),bs(z)))
,and#(ge(x,max(y)),ge(min(z),x))
,ge#(x,max(y))
,max#(y)
,ge#(min(z),x)
,min#(z)
,and#(bs(y),bs(z))
,bs#(y)
,bs#(z))
-->_6 min#(n(x,y,z)) -> c_31(min#(y)):17
-->_4 max#(n(x,y,z)) -> c_29(max#(z)):16
-->_5 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_3 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_5 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_3 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_5 ge#(0(x),1(y)) -> c_23(not#(ge(y,x)),ge#(y,x)):13
-->_3 ge#(0(x),1(y)) -> c_23(not#(ge(y,x)),ge#(y,x)):13
-->_5 ge#(0(x),0(y)) -> c_22(ge#(x,y)):12
-->_3 ge#(0(x),0(y)) -> c_22(ge#(x,y)):12
-->_5 ge#(#(),0(x)) -> c_20(ge#(#(),x)):11
-->_3 ge#(#(),0(x)) -> c_20(ge#(#(),x)):11
-->_6 min#(l(x)) -> c_30():33
-->_4 max#(l(x)) -> c_28():32
-->_5 ge#(#(),1(x)) -> c_21():29
-->_3 ge#(#(),1(x)) -> c_21():29
-->_5 ge#(x,#()) -> c_19():28
-->_3 ge#(x,#()) -> c_19():28
-->_9 bs#(l(x)) -> c_17():27
-->_8 bs#(l(x)) -> c_17():27
-->_7 and#(x,true()) -> c_16():26
-->_2 and#(x,true()) -> c_16():26
-->_1 and#(x,true()) -> c_16():26
-->_7 and#(x,false()) -> c_15():25
-->_2 and#(x,false()) -> c_15():25
-->_1 and#(x,false()) -> c_15():25
-->_9 bs#(n(x,y,z)) -> c_18(and#(and(ge(x,max(y)),ge(min(z),x)),and(bs(y),bs(z)))
,and#(ge(x,max(y)),ge(min(z),x))
,ge#(x,max(y))
,max#(y)
,ge#(min(z),x)
,min#(z)
,and#(bs(y),bs(z))
,bs#(y)
,bs#(z)):10
-->_8 bs#(n(x,y,z)) -> c_18(and#(and(ge(x,max(y)),ge(min(z),x)),and(bs(y),bs(z)))
,and#(ge(x,max(y)),ge(min(z),x))
,ge#(x,max(y))
,max#(y)
,ge#(min(z),x)
,min#(z)
,and#(bs(y),bs(z))
,bs#(y)
,bs#(z)):10
11:S:ge#(#(),0(x)) -> c_20(ge#(#(),x))
-->_1 ge#(#(),1(x)) -> c_21():29
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):11
12:S:ge#(0(x),0(y)) -> c_22(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_1 ge#(0(x),1(y)) -> c_23(not#(ge(y,x)),ge#(y,x)):13
-->_1 ge#(#(),1(x)) -> c_21():29
-->_1 ge#(x,#()) -> c_19():28
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):12
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):11
13:S:ge#(0(x),1(y)) -> c_23(not#(ge(y,x)),ge#(y,x))
-->_2 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_2 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_1 not#(true()) -> c_33():35
-->_1 not#(false()) -> c_32():34
-->_2 ge#(#(),1(x)) -> c_21():29
-->_2 ge#(x,#()) -> c_19():28
-->_2 ge#(0(x),1(y)) -> c_23(not#(ge(y,x)),ge#(y,x)):13
-->_2 ge#(0(x),0(y)) -> c_22(ge#(x,y)):12
-->_2 ge#(#(),0(x)) -> c_20(ge#(#(),x)):11
14:S:ge#(1(x),0(y)) -> c_24(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_1 ge#(#(),1(x)) -> c_21():29
-->_1 ge#(x,#()) -> c_19():28
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_1 ge#(0(x),1(y)) -> c_23(not#(ge(y,x)),ge#(y,x)):13
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):12
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):11
15:S:ge#(1(x),1(y)) -> c_25(ge#(x,y))
-->_1 ge#(#(),1(x)) -> c_21():29
-->_1 ge#(x,#()) -> c_19():28
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_1 ge#(0(x),1(y)) -> c_23(not#(ge(y,x)),ge#(y,x)):13
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):12
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):11
16:S:max#(n(x,y,z)) -> c_29(max#(z))
-->_1 max#(l(x)) -> c_28():32
-->_1 max#(n(x,y,z)) -> c_29(max#(z)):16
17:S:min#(n(x,y,z)) -> c_31(min#(y))
-->_1 min#(l(x)) -> c_30():33
-->_1 min#(n(x,y,z)) -> c_31(min#(y)):17
18:S:size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
-->_4 size#(l(x)) -> c_34():36
-->_3 size#(l(x)) -> c_34():36
-->_2 +#(#(),x) -> c_3():21
-->_1 +#(#(),x) -> c_3():21
-->_2 +#(x,#()) -> c_1():20
-->_4 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_3 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_2 +#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y)):5
-->_2 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_2 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_2 +#(0(x),0(y)) -> c_4(0#(+(x,y)),+#(x,y)):2
-->_2 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
19:S:wb#(n(x,y,z)) -> c_39(and#(if(ge(size(y),size(z))
,ge(1(#()),-(size(y),size(z)))
,ge(1(#()),-(size(z),size(y))))
,and(wb(y),wb(z)))
,if#(ge(size(y),size(z))
,ge(1(#()),-(size(y),size(z)))
,ge(1(#()),-(size(z),size(y))))
,ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,and#(wb(y),wb(z))
,wb#(y)
,wb#(z))
-->_16 wb#(l(x)) -> c_38():39
-->_15 wb#(l(x)) -> c_38():39
-->_13 size#(l(x)) -> c_34():36
-->_12 size#(l(x)) -> c_34():36
-->_9 size#(l(x)) -> c_34():36
-->_8 size#(l(x)) -> c_34():36
-->_5 size#(l(x)) -> c_34():36
-->_4 size#(l(x)) -> c_34():36
-->_2 if#(true(),x,y) -> c_27():31
-->_2 if#(false(),x,y) -> c_26():30
-->_3 ge#(#(),1(x)) -> c_21():29
-->_10 ge#(x,#()) -> c_19():28
-->_6 ge#(x,#()) -> c_19():28
-->_3 ge#(x,#()) -> c_19():28
-->_14 and#(x,true()) -> c_16():26
-->_1 and#(x,true()) -> c_16():26
-->_14 and#(x,false()) -> c_15():25
-->_1 and#(x,false()) -> c_15():25
-->_11 -#(#(),x) -> c_9():23
-->_7 -#(#(),x) -> c_9():23
-->_11 -#(x,#()) -> c_8():22
-->_7 -#(x,#()) -> c_8():22
-->_16 wb#(n(x,y,z)) -> c_39(and#(if(ge(size(y),size(z))
,ge(1(#()),-(size(y),size(z)))
,ge(1(#()),-(size(z),size(y))))
,and(wb(y),wb(z)))
,if#(ge(size(y),size(z))
,ge(1(#()),-(size(y),size(z)))
,ge(1(#()),-(size(z),size(y))))
,ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,and#(wb(y),wb(z))
,wb#(y)
,wb#(z)):19
-->_15 wb#(n(x,y,z)) -> c_39(and#(if(ge(size(y),size(z))
,ge(1(#()),-(size(y),size(z)))
,ge(1(#()),-(size(z),size(y))))
,and(wb(y),wb(z)))
,if#(ge(size(y),size(z))
,ge(1(#()),-(size(y),size(z)))
,ge(1(#()),-(size(z),size(y))))
,ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,and#(wb(y),wb(z))
,wb#(y)
,wb#(z)):19
-->_13 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_12 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_9 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_8 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_5 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_4 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_10 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_6 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_3 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_10 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_6 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_3 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_3 ge#(0(x),1(y)) -> c_23(not#(ge(y,x)),ge#(y,x)):13
-->_3 ge#(0(x),0(y)) -> c_22(ge#(x,y)):12
-->_3 ge#(#(),0(x)) -> c_20(ge#(#(),x)):11
-->_11 -#(1(x),1(y)) -> c_13(0#(-(x,y)),-#(x,y)):9
-->_7 -#(1(x),1(y)) -> c_13(0#(-(x,y)),-#(x,y)):9
-->_11 -#(1(x),0(y)) -> c_12(-#(x,y)):8
-->_7 -#(1(x),0(y)) -> c_12(-#(x,y)):8
-->_11 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):7
-->_7 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):7
-->_11 -#(0(x),0(y)) -> c_10(0#(-(x,y)),-#(x,y)):6
-->_7 -#(0(x),0(y)) -> c_10(0#(-(x,y)),-#(x,y)):6
20:W:+#(x,#()) -> c_1()
21:W:+#(#(),x) -> c_3()
22:W:-#(x,#()) -> c_8()
23:W:-#(#(),x) -> c_9()
24:W:0#(#()) -> c_14()
25:W:and#(x,false()) -> c_15()
26:W:and#(x,true()) -> c_16()
27:W:bs#(l(x)) -> c_17()
28:W:ge#(x,#()) -> c_19()
29:W:ge#(#(),1(x)) -> c_21()
30:W:if#(false(),x,y) -> c_26()
31:W:if#(true(),x,y) -> c_27()
32:W:max#(l(x)) -> c_28()
33:W:min#(l(x)) -> c_30()
34:W:not#(false()) -> c_32()
35:W:not#(true()) -> c_33()
36:W:size#(l(x)) -> c_34()
37:W:val#(l(x)) -> c_36()
38:W:val#(n(x,y,z)) -> c_37()
39:W:wb#(l(x)) -> c_38()
The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
38: val#(n(x,y,z)) -> c_37()
37: val#(l(x)) -> c_36()
30: if#(false(),x,y) -> c_26()
31: if#(true(),x,y) -> c_27()
39: wb#(l(x)) -> c_38()
36: size#(l(x)) -> c_34()
25: and#(x,false()) -> c_15()
26: and#(x,true()) -> c_16()
27: bs#(l(x)) -> c_17()
34: not#(false()) -> c_32()
35: not#(true()) -> c_33()
28: ge#(x,#()) -> c_19()
29: ge#(#(),1(x)) -> c_21()
32: max#(l(x)) -> c_28()
33: min#(l(x)) -> c_30()
22: -#(x,#()) -> c_8()
23: -#(#(),x) -> c_9()
20: +#(x,#()) -> c_1()
21: +#(#(),x) -> c_3()
24: 0#(#()) -> c_14()
** Step 1.b:5: SimplifyRHS WORST_CASE(?,O(n^4))
+ Considered Problem:
- Strict DPs:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(0#(+(x,y)),+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y))
-#(0(x),0(y)) -> c_10(0#(-(x,y)),-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(0#(-(x,y)),-#(x,y))
bs#(n(x,y,z)) -> c_18(and#(and(ge(x,max(y)),ge(min(z),x)),and(bs(y),bs(z)))
,and#(ge(x,max(y)),ge(min(z),x))
,ge#(x,max(y))
,max#(y)
,ge#(min(z),x)
,min#(z)
,and#(bs(y),bs(z))
,bs#(y)
,bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(not#(ge(y,x)),ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
min#(n(x,y,z)) -> c_31(min#(y))
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(and#(if(ge(size(y),size(z))
,ge(1(#()),-(size(y),size(z)))
,ge(1(#()),-(size(z),size(y))))
,and(wb(y),wb(z)))
,if#(ge(size(y),size(z)),ge(1(#()),-(size(y),size(z))),ge(1(#()),-(size(z),size(y))))
,ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,and#(wb(y),wb(z))
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
and(x,false()) -> false()
and(x,true()) -> x
bs(l(x)) -> true()
bs(n(x,y,z)) -> and(and(ge(x,max(y)),ge(min(z),x)),and(bs(y),bs(z)))
ge(x,#()) -> true()
ge(#(),0(x)) -> ge(#(),x)
ge(#(),1(x)) -> false()
ge(0(x),0(y)) -> ge(x,y)
ge(0(x),1(y)) -> not(ge(y,x))
ge(1(x),0(y)) -> ge(x,y)
ge(1(x),1(y)) -> ge(x,y)
if(false(),x,y) -> y
if(true(),x,y) -> x
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
not(false()) -> true()
not(true()) -> false()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
wb(l(x)) -> true()
wb(n(x,y,z)) -> and(if(ge(size(y),size(z)),ge(1(#()),-(size(y),size(z))),ge(1(#()),-(size(z),size(y))))
,and(wb(y),wb(z)))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/2
,c_5/1,c_6/1,c_7/3,c_8/0,c_9/0,c_10/2,c_11/2,c_12/1,c_13/2,c_14/0,c_15/0,c_16/0,c_17/0,c_18/9,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/2,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/16}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
SimplifyRHS
+ Details:
Consider the dependency graph
1:S:+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
-->_2 +#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y)):5
-->_2 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_1 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_2 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_2 +#(0(x),0(y)) -> c_4(0#(+(x,y)),+#(x,y)):2
-->_1 +#(0(x),0(y)) -> c_4(0#(+(x,y)),+#(x,y)):2
-->_2 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
-->_1 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
2:S:+#(0(x),0(y)) -> c_4(0#(+(x,y)),+#(x,y))
-->_2 +#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y)):5
-->_2 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_2 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_2 +#(0(x),0(y)) -> c_4(0#(+(x,y)),+#(x,y)):2
-->_2 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
3:S:+#(0(x),1(y)) -> c_5(+#(x,y))
-->_1 +#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 +#(0(x),0(y)) -> c_4(0#(+(x,y)),+#(x,y)):2
-->_1 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
4:S:+#(1(x),0(y)) -> c_6(+#(x,y))
-->_1 +#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 +#(0(x),0(y)) -> c_4(0#(+(x,y)),+#(x,y)):2
-->_1 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
5:S:+#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y))
-->_3 +#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y)):5
-->_2 +#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y)):5
-->_3 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_3 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_2 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_3 +#(0(x),0(y)) -> c_4(0#(+(x,y)),+#(x,y)):2
-->_3 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
6:S:-#(0(x),0(y)) -> c_10(0#(-(x,y)),-#(x,y))
-->_2 -#(1(x),1(y)) -> c_13(0#(-(x,y)),-#(x,y)):9
-->_2 -#(1(x),0(y)) -> c_12(-#(x,y)):8
-->_2 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):7
-->_2 -#(0(x),0(y)) -> c_10(0#(-(x,y)),-#(x,y)):6
7:S:-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-->_2 -#(1(x),1(y)) -> c_13(0#(-(x,y)),-#(x,y)):9
-->_1 -#(1(x),1(y)) -> c_13(0#(-(x,y)),-#(x,y)):9
-->_2 -#(1(x),0(y)) -> c_12(-#(x,y)):8
-->_2 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):7
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):7
-->_2 -#(0(x),0(y)) -> c_10(0#(-(x,y)),-#(x,y)):6
8:S:-#(1(x),0(y)) -> c_12(-#(x,y))
-->_1 -#(1(x),1(y)) -> c_13(0#(-(x,y)),-#(x,y)):9
-->_1 -#(1(x),0(y)) -> c_12(-#(x,y)):8
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):7
-->_1 -#(0(x),0(y)) -> c_10(0#(-(x,y)),-#(x,y)):6
9:S:-#(1(x),1(y)) -> c_13(0#(-(x,y)),-#(x,y))
-->_2 -#(1(x),1(y)) -> c_13(0#(-(x,y)),-#(x,y)):9
-->_2 -#(1(x),0(y)) -> c_12(-#(x,y)):8
-->_2 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):7
-->_2 -#(0(x),0(y)) -> c_10(0#(-(x,y)),-#(x,y)):6
10:S:bs#(n(x,y,z)) -> c_18(and#(and(ge(x,max(y)),ge(min(z),x)),and(bs(y),bs(z)))
,and#(ge(x,max(y)),ge(min(z),x))
,ge#(x,max(y))
,max#(y)
,ge#(min(z),x)
,min#(z)
,and#(bs(y),bs(z))
,bs#(y)
,bs#(z))
-->_6 min#(n(x,y,z)) -> c_31(min#(y)):17
-->_4 max#(n(x,y,z)) -> c_29(max#(z)):16
-->_5 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_3 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_5 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_3 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_5 ge#(0(x),1(y)) -> c_23(not#(ge(y,x)),ge#(y,x)):13
-->_3 ge#(0(x),1(y)) -> c_23(not#(ge(y,x)),ge#(y,x)):13
-->_5 ge#(0(x),0(y)) -> c_22(ge#(x,y)):12
-->_3 ge#(0(x),0(y)) -> c_22(ge#(x,y)):12
-->_5 ge#(#(),0(x)) -> c_20(ge#(#(),x)):11
-->_3 ge#(#(),0(x)) -> c_20(ge#(#(),x)):11
-->_9 bs#(n(x,y,z)) -> c_18(and#(and(ge(x,max(y)),ge(min(z),x)),and(bs(y),bs(z)))
,and#(ge(x,max(y)),ge(min(z),x))
,ge#(x,max(y))
,max#(y)
,ge#(min(z),x)
,min#(z)
,and#(bs(y),bs(z))
,bs#(y)
,bs#(z)):10
-->_8 bs#(n(x,y,z)) -> c_18(and#(and(ge(x,max(y)),ge(min(z),x)),and(bs(y),bs(z)))
,and#(ge(x,max(y)),ge(min(z),x))
,ge#(x,max(y))
,max#(y)
,ge#(min(z),x)
,min#(z)
,and#(bs(y),bs(z))
,bs#(y)
,bs#(z)):10
11:S:ge#(#(),0(x)) -> c_20(ge#(#(),x))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):11
12:S:ge#(0(x),0(y)) -> c_22(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_1 ge#(0(x),1(y)) -> c_23(not#(ge(y,x)),ge#(y,x)):13
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):12
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):11
13:S:ge#(0(x),1(y)) -> c_23(not#(ge(y,x)),ge#(y,x))
-->_2 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_2 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_2 ge#(0(x),1(y)) -> c_23(not#(ge(y,x)),ge#(y,x)):13
-->_2 ge#(0(x),0(y)) -> c_22(ge#(x,y)):12
-->_2 ge#(#(),0(x)) -> c_20(ge#(#(),x)):11
14:S:ge#(1(x),0(y)) -> c_24(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_1 ge#(0(x),1(y)) -> c_23(not#(ge(y,x)),ge#(y,x)):13
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):12
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):11
15:S:ge#(1(x),1(y)) -> c_25(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_1 ge#(0(x),1(y)) -> c_23(not#(ge(y,x)),ge#(y,x)):13
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):12
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):11
16:S:max#(n(x,y,z)) -> c_29(max#(z))
-->_1 max#(n(x,y,z)) -> c_29(max#(z)):16
17:S:min#(n(x,y,z)) -> c_31(min#(y))
-->_1 min#(n(x,y,z)) -> c_31(min#(y)):17
18:S:size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
-->_4 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_3 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_2 +#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),1(y)) -> c_7(0#(+(+(x,y),1(#()))),+#(+(x,y),1(#())),+#(x,y)):5
-->_2 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_2 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_2 +#(0(x),0(y)) -> c_4(0#(+(x,y)),+#(x,y)):2
-->_2 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
19:S:wb#(n(x,y,z)) -> c_39(and#(if(ge(size(y),size(z))
,ge(1(#()),-(size(y),size(z)))
,ge(1(#()),-(size(z),size(y))))
,and(wb(y),wb(z)))
,if#(ge(size(y),size(z))
,ge(1(#()),-(size(y),size(z)))
,ge(1(#()),-(size(z),size(y))))
,ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,and#(wb(y),wb(z))
,wb#(y)
,wb#(z))
-->_16 wb#(n(x,y,z)) -> c_39(and#(if(ge(size(y),size(z))
,ge(1(#()),-(size(y),size(z)))
,ge(1(#()),-(size(z),size(y))))
,and(wb(y),wb(z)))
,if#(ge(size(y),size(z))
,ge(1(#()),-(size(y),size(z)))
,ge(1(#()),-(size(z),size(y))))
,ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,and#(wb(y),wb(z))
,wb#(y)
,wb#(z)):19
-->_15 wb#(n(x,y,z)) -> c_39(and#(if(ge(size(y),size(z))
,ge(1(#()),-(size(y),size(z)))
,ge(1(#()),-(size(z),size(y))))
,and(wb(y),wb(z)))
,if#(ge(size(y),size(z))
,ge(1(#()),-(size(y),size(z)))
,ge(1(#()),-(size(z),size(y))))
,ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,and#(wb(y),wb(z))
,wb#(y)
,wb#(z)):19
-->_13 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_12 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_9 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_8 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_5 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_4 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_10 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_6 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_3 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_10 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_6 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_3 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_3 ge#(0(x),1(y)) -> c_23(not#(ge(y,x)),ge#(y,x)):13
-->_3 ge#(0(x),0(y)) -> c_22(ge#(x,y)):12
-->_3 ge#(#(),0(x)) -> c_20(ge#(#(),x)):11
-->_11 -#(1(x),1(y)) -> c_13(0#(-(x,y)),-#(x,y)):9
-->_7 -#(1(x),1(y)) -> c_13(0#(-(x,y)),-#(x,y)):9
-->_11 -#(1(x),0(y)) -> c_12(-#(x,y)):8
-->_7 -#(1(x),0(y)) -> c_12(-#(x,y)):8
-->_11 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):7
-->_7 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):7
-->_11 -#(0(x),0(y)) -> c_10(0#(-(x,y)),-#(x,y)):6
-->_7 -#(0(x),0(y)) -> c_10(0#(-(x,y)),-#(x,y)):6
Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified:
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
** Step 1.b:6: UsableRules WORST_CASE(?,O(n^4))
+ Considered Problem:
- Strict DPs:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
min#(n(x,y,z)) -> c_31(min#(y))
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
and(x,false()) -> false()
and(x,true()) -> x
bs(l(x)) -> true()
bs(n(x,y,z)) -> and(and(ge(x,max(y)),ge(min(z),x)),and(bs(y),bs(z)))
ge(x,#()) -> true()
ge(#(),0(x)) -> ge(#(),x)
ge(#(),1(x)) -> false()
ge(0(x),0(y)) -> ge(x,y)
ge(0(x),1(y)) -> not(ge(y,x))
ge(1(x),0(y)) -> ge(x,y)
ge(1(x),1(y)) -> ge(x,y)
if(false(),x,y) -> y
if(true(),x,y) -> x
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
not(false()) -> true()
not(true()) -> false()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
wb(l(x)) -> true()
wb(n(x,y,z)) -> and(if(ge(size(y),size(z)),ge(1(#()),-(size(y),size(z))),ge(1(#()),-(size(z),size(y))))
,and(wb(y),wb(z)))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/13}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
UsableRules
+ Details:
We replace rewrite rules by usable rules:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
min#(n(x,y,z)) -> c_31(min#(y))
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
** Step 1.b:7: Decompose WORST_CASE(?,O(n^4))
+ Considered Problem:
- Strict DPs:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
min#(n(x,y,z)) -> c_31(min#(y))
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/13}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ 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:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
- Weak DPs:
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
min#(n(x,y,z)) -> c_31(min#(y))
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0
,c_4/1,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0
,c_20/1,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0
,c_35/4,c_36/0,c_37/0,c_38/0,c_39/13}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
Problem (S)
- Strict DPs:
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
min#(n(x,y,z)) -> c_31(min#(y))
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
- Weak DPs:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0
,c_4/1,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0
,c_20/1,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0
,c_35/4,c_36/0,c_37/0,c_38/0,c_39/13}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
*** Step 1.b:7.a:1: RemoveWeakSuffixes WORST_CASE(?,O(n^4))
+ Considered Problem:
- Strict DPs:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
- Weak DPs:
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
min#(n(x,y,z)) -> c_31(min#(y))
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/13}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
RemoveWeakSuffixes
+ Details:
Consider the dependency graph
1:S:+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
-->_2 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_2 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_1 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_2 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_2 +#(0(x),0(y)) -> c_4(+#(x,y)):2
-->_1 +#(0(x),0(y)) -> c_4(+#(x,y)):2
-->_2 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
-->_1 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
2:S:+#(0(x),0(y)) -> c_4(+#(x,y))
-->_1 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 +#(0(x),0(y)) -> c_4(+#(x,y)):2
3:S:+#(0(x),1(y)) -> c_5(+#(x,y))
-->_1 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
-->_1 +#(0(x),0(y)) -> c_4(+#(x,y)):2
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
4:S:+#(1(x),0(y)) -> c_6(+#(x,y))
-->_1 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
-->_1 +#(0(x),0(y)) -> c_4(+#(x,y)):2
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),0(y)) -> c_6(+#(x,y)):4
5:S:+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
-->_2 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
-->_2 +#(0(x),0(y)) -> c_4(+#(x,y)):2
-->_2 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_2 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_2 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
6:W:-#(0(x),0(y)) -> c_10(-#(x,y))
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):9
-->_1 -#(1(x),0(y)) -> c_12(-#(x,y)):8
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):7
-->_1 -#(0(x),0(y)) -> c_10(-#(x,y)):6
7:W:-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-->_2 -#(0(x),0(y)) -> c_10(-#(x,y)):6
-->_2 -#(1(x),1(y)) -> c_13(-#(x,y)):9
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):9
-->_2 -#(1(x),0(y)) -> c_12(-#(x,y)):8
-->_2 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):7
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):7
8:W:-#(1(x),0(y)) -> c_12(-#(x,y))
-->_1 -#(0(x),0(y)) -> c_10(-#(x,y)):6
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):7
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):9
-->_1 -#(1(x),0(y)) -> c_12(-#(x,y)):8
9:W:-#(1(x),1(y)) -> c_13(-#(x,y))
-->_1 -#(0(x),0(y)) -> c_10(-#(x,y)):6
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):7
-->_1 -#(1(x),0(y)) -> c_12(-#(x,y)):8
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):9
10:W:bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
-->_4 min#(n(x,y,z)) -> c_31(min#(y)):17
-->_2 max#(n(x,y,z)) -> c_29(max#(z)):16
-->_3 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_3 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_3 ge#(0(x),1(y)) -> c_23(ge#(y,x)):13
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):13
-->_3 ge#(0(x),0(y)) -> c_22(ge#(x,y)):12
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):12
-->_3 ge#(#(),0(x)) -> c_20(ge#(#(),x)):11
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):11
-->_6 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z)):10
-->_5 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z)):10
11:W:ge#(#(),0(x)) -> c_20(ge#(#(),x))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):11
12:W:ge#(0(x),0(y)) -> c_22(ge#(x,y))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):11
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):13
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):12
13:W:ge#(0(x),1(y)) -> c_23(ge#(y,x))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):11
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):12
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):13
14:W:ge#(1(x),0(y)) -> c_24(ge#(x,y))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):11
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):12
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):13
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
15:W:ge#(1(x),1(y)) -> c_25(ge#(x,y))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):11
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):12
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):13
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
16:W:max#(n(x,y,z)) -> c_29(max#(z))
-->_1 max#(n(x,y,z)) -> c_29(max#(z)):16
17:W:min#(n(x,y,z)) -> c_31(min#(y))
-->_1 min#(n(x,y,z)) -> c_31(min#(y)):17
18:W:size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
-->_2 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
-->_2 +#(0(x),0(y)) -> c_4(+#(x,y)):2
-->_2 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_2 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_2 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_4 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_3 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
19:W:wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
-->_9 -#(0(x),0(y)) -> c_10(-#(x,y)):6
-->_5 -#(0(x),0(y)) -> c_10(-#(x,y)):6
-->_9 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):7
-->_5 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):7
-->_9 -#(1(x),0(y)) -> c_12(-#(x,y)):8
-->_5 -#(1(x),0(y)) -> c_12(-#(x,y)):8
-->_9 -#(1(x),1(y)) -> c_13(-#(x,y)):9
-->_5 -#(1(x),1(y)) -> c_13(-#(x,y)):9
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):11
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):12
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):13
-->_8 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_4 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):14
-->_8 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_4 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):15
-->_11 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_10 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_7 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_6 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_3 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_2 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_13 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z)):19
-->_12 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z)):19
The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
10: bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
15: ge#(1(x),1(y)) -> c_25(ge#(x,y))
14: ge#(1(x),0(y)) -> c_24(ge#(x,y))
13: ge#(0(x),1(y)) -> c_23(ge#(y,x))
12: ge#(0(x),0(y)) -> c_22(ge#(x,y))
11: ge#(#(),0(x)) -> c_20(ge#(#(),x))
16: max#(n(x,y,z)) -> c_29(max#(z))
17: min#(n(x,y,z)) -> c_31(min#(y))
6: -#(0(x),0(y)) -> c_10(-#(x,y))
9: -#(1(x),1(y)) -> c_13(-#(x,y))
8: -#(1(x),0(y)) -> c_12(-#(x,y))
7: -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
*** Step 1.b:7.a:2: SimplifyRHS WORST_CASE(?,O(n^4))
+ Considered Problem:
- Strict DPs:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
- Weak DPs:
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/13}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
SimplifyRHS
+ Details:
Consider the dependency graph
1:S:+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
-->_2 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_2 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_1 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_2 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_2 +#(0(x),0(y)) -> c_4(+#(x,y)):2
-->_1 +#(0(x),0(y)) -> c_4(+#(x,y)):2
-->_2 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
-->_1 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
2:S:+#(0(x),0(y)) -> c_4(+#(x,y))
-->_1 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 +#(0(x),0(y)) -> c_4(+#(x,y)):2
3:S:+#(0(x),1(y)) -> c_5(+#(x,y))
-->_1 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
-->_1 +#(0(x),0(y)) -> c_4(+#(x,y)):2
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
4:S:+#(1(x),0(y)) -> c_6(+#(x,y))
-->_1 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
-->_1 +#(0(x),0(y)) -> c_4(+#(x,y)):2
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),0(y)) -> c_6(+#(x,y)):4
5:S:+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
-->_2 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
-->_2 +#(0(x),0(y)) -> c_4(+#(x,y)):2
-->_2 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_2 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_2 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
18:W:size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
-->_2 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
-->_2 +#(0(x),0(y)) -> c_4(+#(x,y)):2
-->_2 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_2 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_2 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_4 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_3 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
19:W:wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
-->_11 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_10 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_7 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_6 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_3 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_2 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):18
-->_13 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z)):19
-->_12 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z)):19
Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified:
wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
*** Step 1.b:7.a:3: UsableRules WORST_CASE(?,O(n^4))
+ Considered Problem:
- Strict DPs:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
- Weak DPs:
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
UsableRules
+ Details:
We replace rewrite rules by usable rules:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
*** Step 1.b:7.a:4: DecomposeDG WORST_CASE(?,O(n^4))
+ Considered Problem:
- Strict DPs:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
- Weak DPs:
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ 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
wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
and a lower component
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
Further, following extension rules are added to the lower component.
wb#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(z)
wb#(n(x,y,z)) -> wb#(y)
wb#(n(x,y,z)) -> wb#(z)
**** Step 1.b:7.a:4.a:1: PredecessorEstimationCP WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ 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: wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
The strictly oriented rules are moved into the weak component.
***** Step 1.b:7.a:4.a:1.a:1: NaturalMI WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ 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_39) = {7,8}
Following symbols are considered usable:
{+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#,wb#}
TcT has computed the following interpretation:
p(#) = [0]
p(+) = [1] x2 + [0]
p(-) = [0]
p(0) = [0]
p(1) = [1] x1 + [0]
p(and) = [0]
p(bs) = [0]
p(false) = [0]
p(ge) = [0]
p(if) = [0]
p(l) = [1] x1 + [0]
p(max) = [0]
p(min) = [0]
p(n) = [1] x1 + [1] x2 + [1] x3 + [4]
p(not) = [0]
p(size) = [0]
p(true) = [0]
p(val) = [0]
p(wb) = [0]
p(+#) = [0]
p(-#) = [0]
p(0#) = [0]
p(and#) = [0]
p(bs#) = [1] x1 + [0]
p(ge#) = [2]
p(if#) = [1]
p(max#) = [1] x1 + [4]
p(min#) = [4] x1 + [2]
p(not#) = [1]
p(size#) = [1]
p(val#) = [1] x1 + [4]
p(wb#) = [4] x1 + [0]
p(c_1) = [2]
p(c_2) = [4] x1 + [1]
p(c_3) = [2]
p(c_4) = [1] x1 + [2]
p(c_5) = [1]
p(c_6) = [1] x1 + [0]
p(c_7) = [1] x1 + [2] x2 + [2]
p(c_8) = [1]
p(c_9) = [4]
p(c_10) = [1] x1 + [1]
p(c_11) = [1] x1 + [1] x2 + [1]
p(c_12) = [1]
p(c_13) = [4]
p(c_14) = [0]
p(c_15) = [1]
p(c_16) = [0]
p(c_17) = [2]
p(c_18) = [1] x3 + [1]
p(c_19) = [1]
p(c_20) = [1] x1 + [0]
p(c_21) = [1]
p(c_22) = [1] x1 + [8]
p(c_23) = [1]
p(c_24) = [1]
p(c_25) = [0]
p(c_26) = [1]
p(c_27) = [2]
p(c_28) = [0]
p(c_29) = [1] x1 + [2]
p(c_30) = [0]
p(c_31) = [2]
p(c_32) = [4]
p(c_33) = [0]
p(c_34) = [2]
p(c_35) = [8] x1 + [1] x4 + [0]
p(c_36) = [1]
p(c_37) = [1]
p(c_38) = [1]
p(c_39) = [2] x1 + [7] x2 + [2] x4 + [1] x7 + [1] x8 + [3]
Following rules are strictly oriented:
wb#(n(x,y,z)) = [4] x + [4] y + [4] z + [16]
> [4] y + [4] z + [14]
= c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
Following rules are (at-least) weakly oriented:
***** Step 1.b:7.a:4.a:1.a:2: Assumption WORST_CASE(?,O(1))
+ Considered Problem:
- Weak DPs:
wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
+ Details:
()
***** Step 1.b:7.a:4.a:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1))
+ Considered Problem:
- Weak DPs:
wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
RemoveWeakSuffixes
+ Details:
Consider the dependency graph
1:W:wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
-->_8 wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z)):1
-->_7 wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z)):1
The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
1: wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
***** Step 1.b:7.a:4.a:1.b:2: EmptyProcessor WORST_CASE(?,O(1))
+ Considered Problem:
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
EmptyProcessor
+ Details:
The problem is already closed. The intended complexity is O(1).
**** Step 1.b:7.a:4.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^3))
+ Considered Problem:
- Strict DPs:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
- Weak DPs:
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(z)
wb#(n(x,y,z)) -> wb#(y)
wb#(n(x,y,z)) -> wb#(z)
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}}
+ Details:
We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
3: +#(0(x),1(y)) -> c_5(+#(x,y))
The strictly oriented rules are moved into the weak component.
***** Step 1.b:7.a:4.b:1.a:1: NaturalPI WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
- Weak DPs:
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(z)
wb#(n(x,y,z)) -> wb#(y)
wb#(n(x,y,z)) -> wb#(z)
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
NaturalPI {shape = Mixed 2, restrict = Restrict, 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 polynomial interpretation of kind constructor-based(mixed(2)):
The following argument positions are considered usable:
uargs(c_2) = {1,2},
uargs(c_4) = {1},
uargs(c_5) = {1},
uargs(c_6) = {1},
uargs(c_7) = {1,2},
uargs(c_35) = {1,2,3,4}
Following symbols are considered usable:
{+,0,size,+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#,wb#}
TcT has computed the following interpretation:
p(#) = 0
p(+) = x1 + x2
p(-) = 0
p(0) = x1
p(1) = 1 + x1
p(and) = 0
p(bs) = 0
p(false) = 0
p(ge) = 0
p(if) = 0
p(l) = 1
p(max) = 0
p(min) = 0
p(n) = 1 + x1 + x2 + x3
p(not) = 0
p(size) = x1
p(true) = 0
p(val) = 0
p(wb) = 0
p(+#) = x2
p(-#) = 0
p(0#) = 0
p(and#) = 0
p(bs#) = 0
p(ge#) = 0
p(if#) = 0
p(max#) = 0
p(min#) = 0
p(not#) = 0
p(size#) = 1 + x1 + x1^2
p(val#) = 0
p(wb#) = 1 + x1^2
p(c_1) = 0
p(c_2) = x1 + x2
p(c_3) = 0
p(c_4) = x1
p(c_5) = x1
p(c_6) = x1
p(c_7) = x1 + x2
p(c_8) = 0
p(c_9) = 0
p(c_10) = 0
p(c_11) = 0
p(c_12) = 0
p(c_13) = 0
p(c_14) = 0
p(c_15) = 0
p(c_16) = 0
p(c_17) = 0
p(c_18) = 0
p(c_19) = 0
p(c_20) = 0
p(c_21) = 0
p(c_22) = 0
p(c_23) = 0
p(c_24) = 0
p(c_25) = 0
p(c_26) = 0
p(c_27) = 0
p(c_28) = 0
p(c_29) = 0
p(c_30) = 0
p(c_31) = 0
p(c_32) = 0
p(c_33) = 0
p(c_34) = 0
p(c_35) = x1 + x2 + x3 + x4
p(c_36) = 0
p(c_37) = 0
p(c_38) = 0
p(c_39) = 0
Following rules are strictly oriented:
+#(0(x),1(y)) = 1 + y
> y
= c_5(+#(x,y))
Following rules are (at-least) weakly oriented:
+#(x,+(y,z)) = y + z
>= y + z
= c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) = y
>= y
= c_4(+#(x,y))
+#(1(x),0(y)) = y
>= y
= c_6(+#(x,y))
+#(1(x),1(y)) = 1 + y
>= 1 + y
= c_7(+#(+(x,y),1(#())),+#(x,y))
size#(n(x,y,z)) = 3 + 3*x + 2*x*y + 2*x*z + x^2 + 3*y + 2*y*z + y^2 + 3*z + z^2
>= 3 + x + x^2 + 2*y + y^2
= c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) = 2 + 2*x + 2*x*y + 2*x*z + x^2 + 2*y + 2*y*z + y^2 + 2*z + z^2
>= 1 + y + y^2
= size#(y)
wb#(n(x,y,z)) = 2 + 2*x + 2*x*y + 2*x*z + x^2 + 2*y + 2*y*z + y^2 + 2*z + z^2
>= 1 + z + z^2
= size#(z)
wb#(n(x,y,z)) = 2 + 2*x + 2*x*y + 2*x*z + x^2 + 2*y + 2*y*z + y^2 + 2*z + z^2
>= 1 + y^2
= wb#(y)
wb#(n(x,y,z)) = 2 + 2*x + 2*x*y + 2*x*z + x^2 + 2*y + 2*y*z + y^2 + 2*z + z^2
>= 1 + z^2
= wb#(z)
+(x,#()) = x
>= x
= x
+(x,+(y,z)) = x + y + z
>= x + y + z
= +(+(x,y),z)
+(#(),x) = x
>= x
= x
+(0(x),0(y)) = x + y
>= x + y
= 0(+(x,y))
+(0(x),1(y)) = 1 + x + y
>= 1 + x + y
= 1(+(x,y))
+(1(x),0(y)) = 1 + x + y
>= 1 + x + y
= 1(+(x,y))
+(1(x),1(y)) = 2 + x + y
>= 1 + x + y
= 0(+(+(x,y),1(#())))
0(#()) = 0
>= 0
= #()
size(l(x)) = 1
>= 1
= 1(#())
size(n(x,y,z)) = 1 + x + y + z
>= 1 + x + y
= +(+(size(x),size(y)),1(#()))
***** Step 1.b:7.a:4.b:1.a:2: Assumption WORST_CASE(?,O(1))
+ Considered Problem:
- Strict DPs:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
- Weak DPs:
+#(0(x),1(y)) -> c_5(+#(x,y))
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(z)
wb#(n(x,y,z)) -> wb#(y)
wb#(n(x,y,z)) -> wb#(z)
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
+ Details:
()
***** Step 1.b:7.a:4.b:1.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^3))
+ Considered Problem:
- Strict DPs:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
- Weak DPs:
+#(0(x),1(y)) -> c_5(+#(x,y))
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(z)
wb#(n(x,y,z)) -> wb#(y)
wb#(n(x,y,z)) -> wb#(z)
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}}
+ Details:
We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
2: +#(0(x),0(y)) -> c_4(+#(x,y))
3: +#(1(x),0(y)) -> c_6(+#(x,y))
The strictly oriented rules are moved into the weak component.
****** Step 1.b:7.a:4.b:1.b:1.a:1: NaturalPI WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
- Weak DPs:
+#(0(x),1(y)) -> c_5(+#(x,y))
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(z)
wb#(n(x,y,z)) -> wb#(y)
wb#(n(x,y,z)) -> wb#(z)
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
NaturalPI {shape = Mixed 2, restrict = Restrict, 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 polynomial interpretation of kind constructor-based(mixed(2)):
The following argument positions are considered usable:
uargs(c_2) = {1,2},
uargs(c_4) = {1},
uargs(c_5) = {1},
uargs(c_6) = {1},
uargs(c_7) = {1,2},
uargs(c_35) = {1,2,3,4}
Following symbols are considered usable:
{+,0,size,+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#,wb#}
TcT has computed the following interpretation:
p(#) = 0
p(+) = x1 + x2
p(-) = 0
p(0) = 1 + x1
p(1) = 1 + x1
p(and) = 0
p(bs) = 0
p(false) = 0
p(ge) = 0
p(if) = 0
p(l) = 1
p(max) = 0
p(min) = 0
p(n) = 1 + x1 + x2 + x3
p(not) = 0
p(size) = x1
p(true) = 0
p(val) = 0
p(wb) = 0
p(+#) = x2
p(-#) = 0
p(0#) = 0
p(and#) = 0
p(bs#) = 0
p(ge#) = 0
p(if#) = 0
p(max#) = 0
p(min#) = 0
p(not#) = 0
p(size#) = x1 + x1^2
p(val#) = 0
p(wb#) = x1^2
p(c_1) = 0
p(c_2) = x1 + x2
p(c_3) = 0
p(c_4) = x1
p(c_5) = 1 + x1
p(c_6) = x1
p(c_7) = x1 + x2
p(c_8) = 0
p(c_9) = 0
p(c_10) = 0
p(c_11) = 0
p(c_12) = 0
p(c_13) = 0
p(c_14) = 0
p(c_15) = 0
p(c_16) = 0
p(c_17) = 0
p(c_18) = 0
p(c_19) = 0
p(c_20) = 0
p(c_21) = 0
p(c_22) = 0
p(c_23) = 0
p(c_24) = 0
p(c_25) = 0
p(c_26) = 0
p(c_27) = 0
p(c_28) = 0
p(c_29) = 0
p(c_30) = 0
p(c_31) = 0
p(c_32) = 0
p(c_33) = 0
p(c_34) = 0
p(c_35) = 1 + x1 + x2 + x3 + x4
p(c_36) = 0
p(c_37) = 0
p(c_38) = 0
p(c_39) = 0
Following rules are strictly oriented:
+#(0(x),0(y)) = 1 + y
> y
= c_4(+#(x,y))
+#(1(x),0(y)) = 1 + y
> y
= c_6(+#(x,y))
Following rules are (at-least) weakly oriented:
+#(x,+(y,z)) = y + z
>= y + z
= c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),1(y)) = 1 + y
>= 1 + y
= c_5(+#(x,y))
+#(1(x),1(y)) = 1 + y
>= 1 + y
= c_7(+#(+(x,y),1(#())),+#(x,y))
size#(n(x,y,z)) = 2 + 3*x + 2*x*y + 2*x*z + x^2 + 3*y + 2*y*z + y^2 + 3*z + z^2
>= 2 + x + x^2 + 2*y + y^2
= c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) = 1 + 2*x + 2*x*y + 2*x*z + x^2 + 2*y + 2*y*z + y^2 + 2*z + z^2
>= y + y^2
= size#(y)
wb#(n(x,y,z)) = 1 + 2*x + 2*x*y + 2*x*z + x^2 + 2*y + 2*y*z + y^2 + 2*z + z^2
>= z + z^2
= size#(z)
wb#(n(x,y,z)) = 1 + 2*x + 2*x*y + 2*x*z + x^2 + 2*y + 2*y*z + y^2 + 2*z + z^2
>= y^2
= wb#(y)
wb#(n(x,y,z)) = 1 + 2*x + 2*x*y + 2*x*z + x^2 + 2*y + 2*y*z + y^2 + 2*z + z^2
>= z^2
= wb#(z)
+(x,#()) = x
>= x
= x
+(x,+(y,z)) = x + y + z
>= x + y + z
= +(+(x,y),z)
+(#(),x) = x
>= x
= x
+(0(x),0(y)) = 2 + x + y
>= 1 + x + y
= 0(+(x,y))
+(0(x),1(y)) = 2 + x + y
>= 1 + x + y
= 1(+(x,y))
+(1(x),0(y)) = 2 + x + y
>= 1 + x + y
= 1(+(x,y))
+(1(x),1(y)) = 2 + x + y
>= 2 + x + y
= 0(+(+(x,y),1(#())))
0(#()) = 1
>= 0
= #()
size(l(x)) = 1
>= 1
= 1(#())
size(n(x,y,z)) = 1 + x + y + z
>= 1 + x + y
= +(+(size(x),size(y)),1(#()))
****** Step 1.b:7.a:4.b:1.b:1.a:2: Assumption WORST_CASE(?,O(1))
+ Considered Problem:
- Strict DPs:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
- Weak DPs:
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(z)
wb#(n(x,y,z)) -> wb#(y)
wb#(n(x,y,z)) -> wb#(z)
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
+ Details:
()
****** Step 1.b:7.a:4.b:1.b:1.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^3))
+ Considered Problem:
- Strict DPs:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
- Weak DPs:
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(z)
wb#(n(x,y,z)) -> wb#(y)
wb#(n(x,y,z)) -> wb#(z)
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalMI {miDimension = 2, miDegree = 2, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}}
+ Details:
We first use the processor NaturalMI {miDimension = 2, miDegree = 2, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
1: +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
The strictly oriented rules are moved into the weak component.
******* Step 1.b:7.a:4.b:1.b:1.b:1.a:1: NaturalMI WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
- Weak DPs:
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(z)
wb#(n(x,y,z)) -> wb#(y)
wb#(n(x,y,z)) -> wb#(z)
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
NaturalMI {miDimension = 2, miDegree = 2, 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,2},
uargs(c_4) = {1},
uargs(c_5) = {1},
uargs(c_6) = {1},
uargs(c_7) = {1,2},
uargs(c_35) = {1,2,3,4}
Following symbols are considered usable:
{+,0,size,+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#,wb#}
TcT has computed the following interpretation:
p(#) = [0]
[0]
p(+) = [1 0] x1 + [2 0] x2 + [0]
[0 1] [0 1] [1]
p(-) = [2 0] x1 + [0 0] x2 + [0]
[0 1] [0 1] [0]
p(0) = [0 0] x1 + [0]
[0 1] [0]
p(1) = [0 0] x1 + [0]
[0 1] [1]
p(and) = [0 0] x1 + [0]
[1 1] [0]
p(bs) = [0]
[0]
p(false) = [1]
[0]
p(ge) = [0 0] x2 + [0]
[1 0] [1]
p(if) = [0 0] x3 + [2]
[1 1] [0]
p(l) = [0]
[2]
p(max) = [2]
[1]
p(min) = [0]
[0]
p(n) = [1 3] x1 + [1 3] x2 + [1 1] x3 + [3]
[0 1] [0 1] [0 1] [3]
p(not) = [0]
[0]
p(size) = [0 0] x1 + [0]
[0 1] [0]
p(true) = [2]
[0]
p(val) = [2 1] x1 + [0]
[2 2] [0]
p(wb) = [0 0] x1 + [0]
[0 1] [0]
p(+#) = [0 2] x2 + [0]
[0 0] [1]
p(-#) = [0 0] x1 + [0 0] x2 + [0]
[0 1] [0 2] [0]
p(0#) = [2 0] x1 + [0]
[0 0] [0]
p(and#) = [0]
[0]
p(bs#) = [0 0] x1 + [1]
[0 1] [0]
p(ge#) = [0]
[0]
p(if#) = [0 0] x2 + [0 0] x3 + [0]
[2 0] [0 1] [2]
p(max#) = [0 0] x1 + [0]
[0 1] [1]
p(min#) = [0 2] x1 + [0]
[1 1] [2]
p(not#) = [0 0] x1 + [0]
[1 2] [0]
p(size#) = [1 1] x1 + [0]
[0 1] [0]
p(val#) = [1 0] x1 + [0]
[0 0] [1]
p(wb#) = [2 0] x1 + [0]
[0 2] [0]
p(c_1) = [0]
[0]
p(c_2) = [1 0] x1 + [1 1] x2 + [0]
[0 0] [0 1] [0]
p(c_3) = [0]
[0]
p(c_4) = [1 0] x1 + [0]
[0 0] [0]
p(c_5) = [1 0] x1 + [0]
[0 0] [0]
p(c_6) = [1 0] x1 + [0]
[0 0] [0]
p(c_7) = [1 0] x1 + [1 0] x2 + [0]
[0 0] [0 1] [0]
p(c_8) = [2]
[1]
p(c_9) = [0]
[1]
p(c_10) = [0 0] x1 + [1]
[0 1] [0]
p(c_11) = [2 1] x1 + [2 2] x2 + [1]
[0 2] [0 1] [2]
p(c_12) = [2 1] x1 + [0]
[1 2] [0]
p(c_13) = [1 0] x1 + [1]
[0 2] [2]
p(c_14) = [2]
[0]
p(c_15) = [1]
[0]
p(c_16) = [0]
[0]
p(c_17) = [0]
[0]
p(c_18) = [0 0] x1 + [0 0] x2 + [0 1] x3 + [0 1] x5 + [0]
[2 0] [0 1] [0 0] [0 0] [0]
p(c_19) = [0]
[0]
p(c_20) = [0]
[0]
p(c_21) = [0]
[2]
p(c_22) = [1 0] x1 + [1]
[0 1] [2]
p(c_23) = [0 0] x1 + [0]
[1 1] [2]
p(c_24) = [0 0] x1 + [0]
[1 2] [0]
p(c_25) = [0]
[0]
p(c_26) = [1]
[0]
p(c_27) = [0]
[0]
p(c_28) = [0]
[2]
p(c_29) = [1 0] x1 + [2]
[1 0] [0]
p(c_30) = [2]
[0]
p(c_31) = [0]
[0]
p(c_32) = [0]
[2]
p(c_33) = [1]
[0]
p(c_34) = [2]
[2]
p(c_35) = [1 1] x1 + [1 0] x2 + [1 1] x3 + [1 1] x4 + [3]
[0 0] [0 0] [0 0] [0 0] [0]
p(c_36) = [0]
[0]
p(c_37) = [0]
[0]
p(c_38) = [0]
[1]
p(c_39) = [0 0] x8 + [0]
[0 1] [1]
Following rules are strictly oriented:
+#(x,+(y,z)) = [0 2] y + [0 2] z + [2]
[0 0] [0 0] [1]
> [0 2] y + [0 2] z + [1]
[0 0] [0 0] [1]
= c_2(+#(+(x,y),z),+#(x,y))
Following rules are (at-least) weakly oriented:
+#(0(x),0(y)) = [0 2] y + [0]
[0 0] [1]
>= [0 2] y + [0]
[0 0] [0]
= c_4(+#(x,y))
+#(0(x),1(y)) = [0 2] y + [2]
[0 0] [1]
>= [0 2] y + [0]
[0 0] [0]
= c_5(+#(x,y))
+#(1(x),0(y)) = [0 2] y + [0]
[0 0] [1]
>= [0 2] y + [0]
[0 0] [0]
= c_6(+#(x,y))
+#(1(x),1(y)) = [0 2] y + [2]
[0 0] [1]
>= [0 2] y + [2]
[0 0] [1]
= c_7(+#(+(x,y),1(#())),+#(x,y))
size#(n(x,y,z)) = [1 4] x + [1 4] y + [1 2] z + [6]
[0 1] [0 1] [0 1] [3]
>= [1 2] x + [1 4] y + [6]
[0 0] [0 0] [0]
= c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) = [2 6] x + [2 6] y + [2 2] z + [6]
[0 2] [0 2] [0 2] [6]
>= [1 1] y + [0]
[0 1] [0]
= size#(y)
wb#(n(x,y,z)) = [2 6] x + [2 6] y + [2 2] z + [6]
[0 2] [0 2] [0 2] [6]
>= [1 1] z + [0]
[0 1] [0]
= size#(z)
wb#(n(x,y,z)) = [2 6] x + [2 6] y + [2 2] z + [6]
[0 2] [0 2] [0 2] [6]
>= [2 0] y + [0]
[0 2] [0]
= wb#(y)
wb#(n(x,y,z)) = [2 6] x + [2 6] y + [2 2] z + [6]
[0 2] [0 2] [0 2] [6]
>= [2 0] z + [0]
[0 2] [0]
= wb#(z)
+(x,#()) = [1 0] x + [0]
[0 1] [1]
>= [1 0] x + [0]
[0 1] [0]
= x
+(x,+(y,z)) = [1 0] x + [2 0] y + [4 0] z + [0]
[0 1] [0 1] [0 1] [2]
>= [1 0] x + [2 0] y + [2 0] z + [0]
[0 1] [0 1] [0 1] [2]
= +(+(x,y),z)
+(#(),x) = [2 0] x + [0]
[0 1] [1]
>= [1 0] x + [0]
[0 1] [0]
= x
+(0(x),0(y)) = [0 0] x + [0 0] y + [0]
[0 1] [0 1] [1]
>= [0 0] x + [0 0] y + [0]
[0 1] [0 1] [1]
= 0(+(x,y))
+(0(x),1(y)) = [0 0] x + [0 0] y + [0]
[0 1] [0 1] [2]
>= [0 0] x + [0 0] y + [0]
[0 1] [0 1] [2]
= 1(+(x,y))
+(1(x),0(y)) = [0 0] x + [0 0] y + [0]
[0 1] [0 1] [2]
>= [0 0] x + [0 0] y + [0]
[0 1] [0 1] [2]
= 1(+(x,y))
+(1(x),1(y)) = [0 0] x + [0 0] y + [0]
[0 1] [0 1] [3]
>= [0 0] x + [0 0] y + [0]
[0 1] [0 1] [3]
= 0(+(+(x,y),1(#())))
0(#()) = [0]
[0]
>= [0]
[0]
= #()
size(l(x)) = [0]
[2]
>= [0]
[1]
= 1(#())
size(n(x,y,z)) = [0 0] x + [0 0] y + [0 0] z + [0]
[0 1] [0 1] [0 1] [3]
>= [0 0] x + [0 0] y + [0]
[0 1] [0 1] [3]
= +(+(size(x),size(y)),1(#()))
******* Step 1.b:7.a:4.b:1.b:1.b:1.a:2: Assumption WORST_CASE(?,O(1))
+ Considered Problem:
- Strict DPs:
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
- Weak DPs:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(z)
wb#(n(x,y,z)) -> wb#(y)
wb#(n(x,y,z)) -> wb#(z)
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
+ Details:
()
******* Step 1.b:7.a:4.b:1.b:1.b:1.b:1: DecomposeDG WORST_CASE(?,O(n^3))
+ Considered Problem:
- Strict DPs:
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
- Weak DPs:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(z)
wb#(n(x,y,z)) -> wb#(y)
wb#(n(x,y,z)) -> wb#(z)
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ 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
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(z)
wb#(n(x,y,z)) -> wb#(y)
wb#(n(x,y,z)) -> wb#(z)
and a lower component
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
Further, following extension rules are added to the lower component.
size#(n(x,y,z)) -> +#(+(size(x),size(y)),1(#()))
size#(n(x,y,z)) -> +#(size(x),size(y))
size#(n(x,y,z)) -> size#(x)
size#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(z)
wb#(n(x,y,z)) -> wb#(y)
wb#(n(x,y,z)) -> wb#(z)
******** Step 1.b:7.a:4.b:1.b:1.b:1.b:1.a:1: PredecessorEstimationCP WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
- Weak DPs:
wb#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(z)
wb#(n(x,y,z)) -> wb#(y)
wb#(n(x,y,z)) -> wb#(z)
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ 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: size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
The strictly oriented rules are moved into the weak component.
********* Step 1.b:7.a:4.b:1.b:1.b:1.b:1.a:1.a:1: NaturalMI WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
- Weak DPs:
wb#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(z)
wb#(n(x,y,z)) -> wb#(y)
wb#(n(x,y,z)) -> wb#(z)
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ 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_35) = {1,2,3,4}
Following symbols are considered usable:
{+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#,wb#}
TcT has computed the following interpretation:
p(#) = [0]
p(+) = [4] x1 + [0]
p(-) = [0]
p(0) = [1] x1 + [5]
p(1) = [1] x1 + [1]
p(and) = [0]
p(bs) = [0]
p(false) = [0]
p(ge) = [0]
p(if) = [0]
p(l) = [0]
p(max) = [0]
p(min) = [0]
p(n) = [1] x1 + [1] x2 + [1] x3 + [7]
p(not) = [0]
p(size) = [1]
p(true) = [0]
p(val) = [0]
p(wb) = [0]
p(+#) = [2]
p(-#) = [0]
p(0#) = [0]
p(and#) = [0]
p(bs#) = [0]
p(ge#) = [0]
p(if#) = [1] x3 + [0]
p(max#) = [1] x1 + [0]
p(min#) = [1] x1 + [0]
p(not#) = [0]
p(size#) = [4] x1 + [0]
p(val#) = [8] x1 + [0]
p(wb#) = [4] x1 + [1]
p(c_1) = [0]
p(c_2) = [1] x2 + [0]
p(c_3) = [0]
p(c_4) = [0]
p(c_5) = [4] x1 + [0]
p(c_6) = [2] x1 + [0]
p(c_7) = [1] x2 + [0]
p(c_8) = [0]
p(c_9) = [0]
p(c_10) = [0]
p(c_11) = [1] x1 + [0]
p(c_12) = [0]
p(c_13) = [1] x1 + [0]
p(c_14) = [0]
p(c_15) = [0]
p(c_16) = [0]
p(c_17) = [0]
p(c_18) = [1] x2 + [1] x3 + [1] x5 + [4] x6 + [0]
p(c_19) = [0]
p(c_20) = [2] x1 + [2]
p(c_21) = [1]
p(c_22) = [1] x1 + [8]
p(c_23) = [1] x1 + [1]
p(c_24) = [0]
p(c_25) = [8] x1 + [1]
p(c_26) = [1]
p(c_27) = [0]
p(c_28) = [1]
p(c_29) = [0]
p(c_30) = [2]
p(c_31) = [2] x1 + [0]
p(c_32) = [2]
p(c_33) = [2]
p(c_34) = [1]
p(c_35) = [7] x1 + [4] x2 + [1] x3 + [1] x4 + [4]
p(c_36) = [4]
p(c_37) = [0]
p(c_38) = [2]
p(c_39) = [1] x2 + [1] x5 + [1] x8 + [0]
Following rules are strictly oriented:
size#(n(x,y,z)) = [4] x + [4] y + [4] z + [28]
> [4] x + [4] y + [26]
= c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
Following rules are (at-least) weakly oriented:
wb#(n(x,y,z)) = [4] x + [4] y + [4] z + [29]
>= [4] y + [0]
= size#(y)
wb#(n(x,y,z)) = [4] x + [4] y + [4] z + [29]
>= [4] z + [0]
= size#(z)
wb#(n(x,y,z)) = [4] x + [4] y + [4] z + [29]
>= [4] y + [1]
= wb#(y)
wb#(n(x,y,z)) = [4] x + [4] y + [4] z + [29]
>= [4] z + [1]
= wb#(z)
********* Step 1.b:7.a:4.b:1.b:1.b:1.b:1.a:1.a:2: Assumption WORST_CASE(?,O(1))
+ Considered Problem:
- Weak DPs:
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(z)
wb#(n(x,y,z)) -> wb#(y)
wb#(n(x,y,z)) -> wb#(z)
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
+ Details:
()
********* Step 1.b:7.a:4.b:1.b:1.b:1.b:1.a:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1))
+ Considered Problem:
- Weak DPs:
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(z)
wb#(n(x,y,z)) -> wb#(y)
wb#(n(x,y,z)) -> wb#(z)
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
RemoveWeakSuffixes
+ Details:
Consider the dependency graph
1:W:size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
-->_4 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):1
-->_3 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):1
2:W:wb#(n(x,y,z)) -> size#(y)
-->_1 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):1
3:W:wb#(n(x,y,z)) -> size#(z)
-->_1 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):1
4:W:wb#(n(x,y,z)) -> wb#(y)
-->_1 wb#(n(x,y,z)) -> wb#(z):5
-->_1 wb#(n(x,y,z)) -> wb#(y):4
-->_1 wb#(n(x,y,z)) -> size#(z):3
-->_1 wb#(n(x,y,z)) -> size#(y):2
5:W:wb#(n(x,y,z)) -> wb#(z)
-->_1 wb#(n(x,y,z)) -> wb#(z):5
-->_1 wb#(n(x,y,z)) -> wb#(y):4
-->_1 wb#(n(x,y,z)) -> size#(z):3
-->_1 wb#(n(x,y,z)) -> size#(y):2
The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
4: wb#(n(x,y,z)) -> wb#(y)
5: wb#(n(x,y,z)) -> wb#(z)
3: wb#(n(x,y,z)) -> size#(z)
2: wb#(n(x,y,z)) -> size#(y)
1: size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
********* Step 1.b:7.a:4.b:1.b:1.b:1.b:1.a:1.b:2: EmptyProcessor WORST_CASE(?,O(1))
+ Considered Problem:
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
EmptyProcessor
+ Details:
The problem is already closed. The intended complexity is O(1).
******** Step 1.b:7.a:4.b:1.b:1.b:1.b:1.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
- Weak DPs:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
size#(n(x,y,z)) -> +#(+(size(x),size(y)),1(#()))
size#(n(x,y,z)) -> +#(size(x),size(y))
size#(n(x,y,z)) -> size#(x)
size#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(z)
wb#(n(x,y,z)) -> wb#(y)
wb#(n(x,y,z)) -> wb#(z)
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}}
+ Details:
We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
1: +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
The strictly oriented rules are moved into the weak component.
********* Step 1.b:7.a:4.b:1.b:1.b:1.b:1.b:1.a:1: NaturalPI WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
- Weak DPs:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
size#(n(x,y,z)) -> +#(+(size(x),size(y)),1(#()))
size#(n(x,y,z)) -> +#(size(x),size(y))
size#(n(x,y,z)) -> size#(x)
size#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(z)
wb#(n(x,y,z)) -> wb#(y)
wb#(n(x,y,z)) -> wb#(z)
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
NaturalPI {shape = Mixed 2, restrict = Restrict, 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 polynomial interpretation of kind constructor-based(mixed(2)):
The following argument positions are considered usable:
uargs(c_2) = {1,2},
uargs(c_4) = {1},
uargs(c_5) = {1},
uargs(c_6) = {1},
uargs(c_7) = {1,2}
Following symbols are considered usable:
{+,0,size,+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#,wb#}
TcT has computed the following interpretation:
p(#) = 0
p(+) = x1 + x2
p(-) = 0
p(0) = x1
p(1) = 1 + x1
p(and) = 0
p(bs) = 0
p(false) = 0
p(ge) = 0
p(if) = 0
p(l) = 1 + x1
p(max) = 0
p(min) = 0
p(n) = 1 + x1 + x2 + x3
p(not) = 0
p(size) = x1
p(true) = 0
p(val) = 0
p(wb) = 0
p(+#) = x1*x2 + x2^2
p(-#) = 0
p(0#) = 0
p(and#) = 0
p(bs#) = 0
p(ge#) = 0
p(if#) = 0
p(max#) = 0
p(min#) = 0
p(not#) = 0
p(size#) = x1^2
p(val#) = 0
p(wb#) = x1^2
p(c_1) = 0
p(c_2) = x1 + x2
p(c_3) = 0
p(c_4) = x1
p(c_5) = 1 + x1
p(c_6) = x1
p(c_7) = x1 + x2
p(c_8) = 0
p(c_9) = 0
p(c_10) = 0
p(c_11) = 0
p(c_12) = 0
p(c_13) = 0
p(c_14) = 0
p(c_15) = 0
p(c_16) = 0
p(c_17) = 0
p(c_18) = 0
p(c_19) = 0
p(c_20) = 0
p(c_21) = 0
p(c_22) = 0
p(c_23) = 0
p(c_24) = 0
p(c_25) = 0
p(c_26) = 0
p(c_27) = 0
p(c_28) = 0
p(c_29) = 0
p(c_30) = 0
p(c_31) = 0
p(c_32) = 0
p(c_33) = 0
p(c_34) = 0
p(c_35) = 0
p(c_36) = 0
p(c_37) = 0
p(c_38) = 0
p(c_39) = 0
Following rules are strictly oriented:
+#(1(x),1(y)) = 2 + x + x*y + 3*y + y^2
> 1 + x + x*y + y + y^2
= c_7(+#(+(x,y),1(#())),+#(x,y))
Following rules are (at-least) weakly oriented:
+#(x,+(y,z)) = x*y + x*z + 2*y*z + y^2 + z^2
>= x*y + x*z + y*z + y^2 + z^2
= c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) = x*y + y^2
>= x*y + y^2
= c_4(+#(x,y))
+#(0(x),1(y)) = 1 + x + x*y + 2*y + y^2
>= 1 + x*y + y^2
= c_5(+#(x,y))
+#(1(x),0(y)) = x*y + y + y^2
>= x*y + y^2
= c_6(+#(x,y))
size#(n(x,y,z)) = 1 + 2*x + 2*x*y + 2*x*z + x^2 + 2*y + 2*y*z + y^2 + 2*z + z^2
>= 1 + x + y
= +#(+(size(x),size(y)),1(#()))
size#(n(x,y,z)) = 1 + 2*x + 2*x*y + 2*x*z + x^2 + 2*y + 2*y*z + y^2 + 2*z + z^2
>= x*y + y^2
= +#(size(x),size(y))
size#(n(x,y,z)) = 1 + 2*x + 2*x*y + 2*x*z + x^2 + 2*y + 2*y*z + y^2 + 2*z + z^2
>= x^2
= size#(x)
size#(n(x,y,z)) = 1 + 2*x + 2*x*y + 2*x*z + x^2 + 2*y + 2*y*z + y^2 + 2*z + z^2
>= y^2
= size#(y)
wb#(n(x,y,z)) = 1 + 2*x + 2*x*y + 2*x*z + x^2 + 2*y + 2*y*z + y^2 + 2*z + z^2
>= y^2
= size#(y)
wb#(n(x,y,z)) = 1 + 2*x + 2*x*y + 2*x*z + x^2 + 2*y + 2*y*z + y^2 + 2*z + z^2
>= z^2
= size#(z)
wb#(n(x,y,z)) = 1 + 2*x + 2*x*y + 2*x*z + x^2 + 2*y + 2*y*z + y^2 + 2*z + z^2
>= y^2
= wb#(y)
wb#(n(x,y,z)) = 1 + 2*x + 2*x*y + 2*x*z + x^2 + 2*y + 2*y*z + y^2 + 2*z + z^2
>= z^2
= wb#(z)
+(x,#()) = x
>= x
= x
+(x,+(y,z)) = x + y + z
>= x + y + z
= +(+(x,y),z)
+(#(),x) = x
>= x
= x
+(0(x),0(y)) = x + y
>= x + y
= 0(+(x,y))
+(0(x),1(y)) = 1 + x + y
>= 1 + x + y
= 1(+(x,y))
+(1(x),0(y)) = 1 + x + y
>= 1 + x + y
= 1(+(x,y))
+(1(x),1(y)) = 2 + x + y
>= 1 + x + y
= 0(+(+(x,y),1(#())))
0(#()) = 0
>= 0
= #()
size(l(x)) = 1 + x
>= 1
= 1(#())
size(n(x,y,z)) = 1 + x + y + z
>= 1 + x + y
= +(+(size(x),size(y)),1(#()))
********* Step 1.b:7.a:4.b:1.b:1.b:1.b:1.b:1.a:2: Assumption WORST_CASE(?,O(1))
+ Considered Problem:
- Weak DPs:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
size#(n(x,y,z)) -> +#(+(size(x),size(y)),1(#()))
size#(n(x,y,z)) -> +#(size(x),size(y))
size#(n(x,y,z)) -> size#(x)
size#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(z)
wb#(n(x,y,z)) -> wb#(y)
wb#(n(x,y,z)) -> wb#(z)
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
+ Details:
()
********* Step 1.b:7.a:4.b:1.b:1.b:1.b:1.b:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1))
+ Considered Problem:
- Weak DPs:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
size#(n(x,y,z)) -> +#(+(size(x),size(y)),1(#()))
size#(n(x,y,z)) -> +#(size(x),size(y))
size#(n(x,y,z)) -> size#(x)
size#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(y)
wb#(n(x,y,z)) -> size#(z)
wb#(n(x,y,z)) -> wb#(y)
wb#(n(x,y,z)) -> wb#(z)
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
RemoveWeakSuffixes
+ Details:
Consider the dependency graph
1:W:+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
-->_2 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_2 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_1 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_2 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_2 +#(0(x),0(y)) -> c_4(+#(x,y)):2
-->_1 +#(0(x),0(y)) -> c_4(+#(x,y)):2
-->_2 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
-->_1 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
2:W:+#(0(x),0(y)) -> c_4(+#(x,y))
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 +#(0(x),0(y)) -> c_4(+#(x,y)):2
-->_1 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
3:W:+#(0(x),1(y)) -> c_5(+#(x,y))
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 +#(0(x),0(y)) -> c_4(+#(x,y)):2
-->_1 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
4:W:+#(1(x),0(y)) -> c_6(+#(x,y))
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 +#(0(x),0(y)) -> c_4(+#(x,y)):2
-->_1 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
5:W:+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
-->_2 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_2 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_2 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_2 +#(0(x),0(y)) -> c_4(+#(x,y)):2
-->_2 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
6:W:size#(n(x,y,z)) -> +#(+(size(x),size(y)),1(#()))
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
7:W:size#(n(x,y,z)) -> +#(size(x),size(y))
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):5
-->_1 +#(1(x),0(y)) -> c_6(+#(x,y)):4
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):3
-->_1 +#(0(x),0(y)) -> c_4(+#(x,y)):2
-->_1 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):1
8:W:size#(n(x,y,z)) -> size#(x)
-->_1 size#(n(x,y,z)) -> size#(y):9
-->_1 size#(n(x,y,z)) -> size#(x):8
-->_1 size#(n(x,y,z)) -> +#(size(x),size(y)):7
-->_1 size#(n(x,y,z)) -> +#(+(size(x),size(y)),1(#())):6
9:W:size#(n(x,y,z)) -> size#(y)
-->_1 size#(n(x,y,z)) -> size#(y):9
-->_1 size#(n(x,y,z)) -> size#(x):8
-->_1 size#(n(x,y,z)) -> +#(size(x),size(y)):7
-->_1 size#(n(x,y,z)) -> +#(+(size(x),size(y)),1(#())):6
10:W:wb#(n(x,y,z)) -> size#(y)
-->_1 size#(n(x,y,z)) -> size#(y):9
-->_1 size#(n(x,y,z)) -> size#(x):8
-->_1 size#(n(x,y,z)) -> +#(size(x),size(y)):7
-->_1 size#(n(x,y,z)) -> +#(+(size(x),size(y)),1(#())):6
11:W:wb#(n(x,y,z)) -> size#(z)
-->_1 size#(n(x,y,z)) -> size#(y):9
-->_1 size#(n(x,y,z)) -> size#(x):8
-->_1 size#(n(x,y,z)) -> +#(size(x),size(y)):7
-->_1 size#(n(x,y,z)) -> +#(+(size(x),size(y)),1(#())):6
12:W:wb#(n(x,y,z)) -> wb#(y)
-->_1 wb#(n(x,y,z)) -> wb#(z):13
-->_1 wb#(n(x,y,z)) -> wb#(y):12
-->_1 wb#(n(x,y,z)) -> size#(z):11
-->_1 wb#(n(x,y,z)) -> size#(y):10
13:W:wb#(n(x,y,z)) -> wb#(z)
-->_1 wb#(n(x,y,z)) -> wb#(z):13
-->_1 wb#(n(x,y,z)) -> wb#(y):12
-->_1 wb#(n(x,y,z)) -> size#(z):11
-->_1 wb#(n(x,y,z)) -> size#(y):10
The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
12: wb#(n(x,y,z)) -> wb#(y)
13: wb#(n(x,y,z)) -> wb#(z)
11: wb#(n(x,y,z)) -> size#(z)
10: wb#(n(x,y,z)) -> size#(y)
8: size#(n(x,y,z)) -> size#(x)
9: size#(n(x,y,z)) -> size#(y)
7: size#(n(x,y,z)) -> +#(size(x),size(y))
6: size#(n(x,y,z)) -> +#(+(size(x),size(y)),1(#()))
1: +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
5: +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
4: +#(1(x),0(y)) -> c_6(+#(x,y))
3: +#(0(x),1(y)) -> c_5(+#(x,y))
2: +#(0(x),0(y)) -> c_4(+#(x,y))
********* Step 1.b:7.a:4.b:1.b:1.b:1.b:1.b:1.b:2: EmptyProcessor WORST_CASE(?,O(1))
+ Considered Problem:
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
EmptyProcessor
+ Details:
The problem is already closed. The intended complexity is O(1).
*** Step 1.b:7.b:1: RemoveWeakSuffixes WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
min#(n(x,y,z)) -> c_31(min#(y))
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
- Weak DPs:
+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
+#(0(x),0(y)) -> c_4(+#(x,y))
+#(0(x),1(y)) -> c_5(+#(x,y))
+#(1(x),0(y)) -> c_6(+#(x,y))
+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/13}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
RemoveWeakSuffixes
+ Details:
Consider the dependency graph
1:S:-#(0(x),0(y)) -> c_10(-#(x,y))
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_1 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_1 -#(0(x),0(y)) -> c_10(-#(x,y)):1
2:S:-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-->_2 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_2 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_2 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_2 -#(0(x),0(y)) -> c_10(-#(x,y)):1
3:S:-#(1(x),0(y)) -> c_12(-#(x,y))
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_1 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_1 -#(0(x),0(y)) -> c_10(-#(x,y)):1
4:S:-#(1(x),1(y)) -> c_13(-#(x,y))
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_1 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_1 -#(0(x),0(y)) -> c_10(-#(x,y)):1
5:S:bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
-->_4 min#(n(x,y,z)) -> c_31(min#(y)):12
-->_2 max#(n(x,y,z)) -> c_29(max#(z)):11
-->_3 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_3 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_3 ge#(0(x),1(y)) -> c_23(ge#(y,x)):8
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):8
-->_3 ge#(0(x),0(y)) -> c_22(ge#(x,y)):7
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):7
-->_3 ge#(#(),0(x)) -> c_20(ge#(#(),x)):6
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):6
-->_6 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z)):5
-->_5 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z)):5
6:S:ge#(#(),0(x)) -> c_20(ge#(#(),x))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):6
7:S:ge#(0(x),0(y)) -> c_22(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):8
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):7
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):6
8:S:ge#(0(x),1(y)) -> c_23(ge#(y,x))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):8
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):7
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):6
9:S:ge#(1(x),0(y)) -> c_24(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):8
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):7
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):6
10:S:ge#(1(x),1(y)) -> c_25(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):8
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):7
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):6
11:S:max#(n(x,y,z)) -> c_29(max#(z))
-->_1 max#(n(x,y,z)) -> c_29(max#(z)):11
12:S:min#(n(x,y,z)) -> c_31(min#(y))
-->_1 min#(n(x,y,z)) -> c_31(min#(y)):12
13:S:size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
-->_2 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):19
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):19
-->_2 +#(1(x),0(y)) -> c_6(+#(x,y)):18
-->_2 +#(0(x),1(y)) -> c_5(+#(x,y)):17
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):17
-->_2 +#(0(x),0(y)) -> c_4(+#(x,y)):16
-->_2 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):15
-->_4 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):13
-->_3 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):13
14:S:wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
-->_13 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z)):14
-->_12 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z)):14
-->_11 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):13
-->_10 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):13
-->_7 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):13
-->_6 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):13
-->_3 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):13
-->_2 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):13
-->_8 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_4 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_8 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_4 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):8
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):7
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):6
-->_9 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_5 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_9 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_5 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_9 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_5 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_9 -#(0(x),0(y)) -> c_10(-#(x,y)):1
-->_5 -#(0(x),0(y)) -> c_10(-#(x,y)):1
15:W:+#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
-->_2 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):19
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):19
-->_2 +#(1(x),0(y)) -> c_6(+#(x,y)):18
-->_1 +#(1(x),0(y)) -> c_6(+#(x,y)):18
-->_2 +#(0(x),1(y)) -> c_5(+#(x,y)):17
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):17
-->_2 +#(0(x),0(y)) -> c_4(+#(x,y)):16
-->_1 +#(0(x),0(y)) -> c_4(+#(x,y)):16
-->_2 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):15
-->_1 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):15
16:W:+#(0(x),0(y)) -> c_4(+#(x,y))
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):19
-->_1 +#(1(x),0(y)) -> c_6(+#(x,y)):18
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):17
-->_1 +#(0(x),0(y)) -> c_4(+#(x,y)):16
-->_1 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):15
17:W:+#(0(x),1(y)) -> c_5(+#(x,y))
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):19
-->_1 +#(1(x),0(y)) -> c_6(+#(x,y)):18
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):17
-->_1 +#(0(x),0(y)) -> c_4(+#(x,y)):16
-->_1 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):15
18:W:+#(1(x),0(y)) -> c_6(+#(x,y))
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):19
-->_1 +#(1(x),0(y)) -> c_6(+#(x,y)):18
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):17
-->_1 +#(0(x),0(y)) -> c_4(+#(x,y)):16
-->_1 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):15
19:W:+#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
-->_2 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):19
-->_1 +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y)):19
-->_2 +#(1(x),0(y)) -> c_6(+#(x,y)):18
-->_2 +#(0(x),1(y)) -> c_5(+#(x,y)):17
-->_1 +#(0(x),1(y)) -> c_5(+#(x,y)):17
-->_2 +#(0(x),0(y)) -> c_4(+#(x,y)):16
-->_2 +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y)):15
The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
19: +#(1(x),1(y)) -> c_7(+#(+(x,y),1(#())),+#(x,y))
18: +#(1(x),0(y)) -> c_6(+#(x,y))
17: +#(0(x),1(y)) -> c_5(+#(x,y))
16: +#(0(x),0(y)) -> c_4(+#(x,y))
15: +#(x,+(y,z)) -> c_2(+#(+(x,y),z),+#(x,y))
*** Step 1.b:7.b:2: SimplifyRHS WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
min#(n(x,y,z)) -> c_31(min#(y))
size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/4
,c_36/0,c_37/0,c_38/0,c_39/13}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
SimplifyRHS
+ Details:
Consider the dependency graph
1:S:-#(0(x),0(y)) -> c_10(-#(x,y))
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_1 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_1 -#(0(x),0(y)) -> c_10(-#(x,y)):1
2:S:-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-->_2 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_2 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_2 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_2 -#(0(x),0(y)) -> c_10(-#(x,y)):1
3:S:-#(1(x),0(y)) -> c_12(-#(x,y))
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_1 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_1 -#(0(x),0(y)) -> c_10(-#(x,y)):1
4:S:-#(1(x),1(y)) -> c_13(-#(x,y))
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_1 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_1 -#(0(x),0(y)) -> c_10(-#(x,y)):1
5:S:bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
-->_4 min#(n(x,y,z)) -> c_31(min#(y)):12
-->_2 max#(n(x,y,z)) -> c_29(max#(z)):11
-->_3 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_3 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_3 ge#(0(x),1(y)) -> c_23(ge#(y,x)):8
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):8
-->_3 ge#(0(x),0(y)) -> c_22(ge#(x,y)):7
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):7
-->_3 ge#(#(),0(x)) -> c_20(ge#(#(),x)):6
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):6
-->_6 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z)):5
-->_5 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z)):5
6:S:ge#(#(),0(x)) -> c_20(ge#(#(),x))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):6
7:S:ge#(0(x),0(y)) -> c_22(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):8
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):7
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):6
8:S:ge#(0(x),1(y)) -> c_23(ge#(y,x))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):8
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):7
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):6
9:S:ge#(1(x),0(y)) -> c_24(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):8
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):7
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):6
10:S:ge#(1(x),1(y)) -> c_25(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):8
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):7
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):6
11:S:max#(n(x,y,z)) -> c_29(max#(z))
-->_1 max#(n(x,y,z)) -> c_29(max#(z)):11
12:S:min#(n(x,y,z)) -> c_31(min#(y))
-->_1 min#(n(x,y,z)) -> c_31(min#(y)):12
13:S:size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y))
-->_4 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):13
-->_3 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):13
14:S:wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
-->_13 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z)):14
-->_12 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z)):14
-->_11 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):13
-->_10 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):13
-->_7 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):13
-->_6 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):13
-->_3 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):13
-->_2 size#(n(x,y,z)) -> c_35(+#(+(size(x),size(y)),1(#())),+#(size(x),size(y)),size#(x),size#(y)):13
-->_8 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_4 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_8 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_4 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):8
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):7
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):6
-->_9 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_5 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_9 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_5 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_9 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_5 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_9 -#(0(x),0(y)) -> c_10(-#(x,y)):1
-->_5 -#(0(x),0(y)) -> c_10(-#(x,y)):1
Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified:
size#(n(x,y,z)) -> c_35(size#(x),size#(y))
*** Step 1.b:7.b:3: Decompose WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
min#(n(x,y,z)) -> c_31(min#(y))
size#(n(x,y,z)) -> c_35(size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/13}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ 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:
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
- Weak DPs:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
min#(n(x,y,z)) -> c_31(min#(y))
size#(n(x,y,z)) -> c_35(size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0
,c_4/1,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0
,c_20/1,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0
,c_35/2,c_36/0,c_37/0,c_38/0,c_39/13}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
Problem (S)
- Strict DPs:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
min#(n(x,y,z)) -> c_31(min#(y))
size#(n(x,y,z)) -> c_35(size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
- Weak DPs:
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0
,c_4/1,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0
,c_20/1,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0
,c_35/2,c_36/0,c_37/0,c_38/0,c_39/13}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
**** Step 1.b:7.b:3.a:1: RemoveWeakSuffixes WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
- Weak DPs:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
min#(n(x,y,z)) -> c_31(min#(y))
size#(n(x,y,z)) -> c_35(size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/13}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
RemoveWeakSuffixes
+ Details:
Consider the dependency graph
1:S:-#(0(x),0(y)) -> c_10(-#(x,y))
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_1 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_1 -#(0(x),0(y)) -> c_10(-#(x,y)):1
2:S:-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-->_2 -#(0(x),0(y)) -> c_10(-#(x,y)):1
-->_2 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_2 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_2 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
3:S:-#(1(x),0(y)) -> c_12(-#(x,y))
-->_1 -#(0(x),0(y)) -> c_10(-#(x,y)):1
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_1 -#(1(x),0(y)) -> c_12(-#(x,y)):3
4:S:-#(1(x),1(y)) -> c_13(-#(x,y))
-->_1 -#(0(x),0(y)) -> c_10(-#(x,y)):1
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_1 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):4
5:W:bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
-->_4 min#(n(x,y,z)) -> c_31(min#(y)):12
-->_2 max#(n(x,y,z)) -> c_29(max#(z)):11
-->_3 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_3 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_3 ge#(0(x),1(y)) -> c_23(ge#(y,x)):8
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):8
-->_3 ge#(0(x),0(y)) -> c_22(ge#(x,y)):7
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):7
-->_3 ge#(#(),0(x)) -> c_20(ge#(#(),x)):6
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):6
-->_6 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z)):5
-->_5 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z)):5
6:W:ge#(#(),0(x)) -> c_20(ge#(#(),x))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):6
7:W:ge#(0(x),0(y)) -> c_22(ge#(x,y))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):6
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):8
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):7
8:W:ge#(0(x),1(y)) -> c_23(ge#(y,x))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):6
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):7
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):8
9:W:ge#(1(x),0(y)) -> c_24(ge#(x,y))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):6
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):7
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):8
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
10:W:ge#(1(x),1(y)) -> c_25(ge#(x,y))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):6
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):7
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):8
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
11:W:max#(n(x,y,z)) -> c_29(max#(z))
-->_1 max#(n(x,y,z)) -> c_29(max#(z)):11
12:W:min#(n(x,y,z)) -> c_31(min#(y))
-->_1 min#(n(x,y,z)) -> c_31(min#(y)):12
13:W:size#(n(x,y,z)) -> c_35(size#(x),size#(y))
-->_2 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):13
-->_1 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):13
14:W:wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
-->_9 -#(0(x),0(y)) -> c_10(-#(x,y)):1
-->_5 -#(0(x),0(y)) -> c_10(-#(x,y)):1
-->_9 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_5 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_9 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_5 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_9 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_5 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):6
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):7
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):8
-->_8 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_4 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):9
-->_8 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_4 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):10
-->_11 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):13
-->_10 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):13
-->_7 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):13
-->_6 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):13
-->_3 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):13
-->_2 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):13
-->_13 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z)):14
-->_12 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z)):14
The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
13: size#(n(x,y,z)) -> c_35(size#(x),size#(y))
5: bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
10: ge#(1(x),1(y)) -> c_25(ge#(x,y))
9: ge#(1(x),0(y)) -> c_24(ge#(x,y))
8: ge#(0(x),1(y)) -> c_23(ge#(y,x))
7: ge#(0(x),0(y)) -> c_22(ge#(x,y))
6: ge#(#(),0(x)) -> c_20(ge#(#(),x))
11: max#(n(x,y,z)) -> c_29(max#(z))
12: min#(n(x,y,z)) -> c_31(min#(y))
**** Step 1.b:7.b:3.a:2: SimplifyRHS WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
- Weak DPs:
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/13}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
SimplifyRHS
+ Details:
Consider the dependency graph
1:S:-#(0(x),0(y)) -> c_10(-#(x,y))
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_1 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_1 -#(0(x),0(y)) -> c_10(-#(x,y)):1
2:S:-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-->_2 -#(0(x),0(y)) -> c_10(-#(x,y)):1
-->_2 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_2 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_2 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
3:S:-#(1(x),0(y)) -> c_12(-#(x,y))
-->_1 -#(0(x),0(y)) -> c_10(-#(x,y)):1
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_1 -#(1(x),0(y)) -> c_12(-#(x,y)):3
4:S:-#(1(x),1(y)) -> c_13(-#(x,y))
-->_1 -#(0(x),0(y)) -> c_10(-#(x,y)):1
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_1 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):4
14:W:wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
-->_9 -#(0(x),0(y)) -> c_10(-#(x,y)):1
-->_5 -#(0(x),0(y)) -> c_10(-#(x,y)):1
-->_9 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_5 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_9 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_5 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_9 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_5 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_13 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z)):14
-->_12 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z)):14
Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified:
wb#(n(x,y,z)) -> c_39(-#(size(y),size(z)),-#(size(z),size(y)),wb#(y),wb#(z))
**** Step 1.b:7.b:3.a:3: UsableRules WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
- Weak DPs:
wb#(n(x,y,z)) -> c_39(-#(size(y),size(z)),-#(size(z),size(y)),wb#(y),wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/4}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
UsableRules
+ Details:
We replace rewrite rules by usable rules:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
wb#(n(x,y,z)) -> c_39(-#(size(y),size(z)),-#(size(z),size(y)),wb#(y),wb#(z))
**** Step 1.b:7.b:3.a:4: PredecessorEstimationCP WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
- Weak DPs:
wb#(n(x,y,z)) -> c_39(-#(size(y),size(z)),-#(size(z),size(y)),wb#(y),wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/4}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}}
+ Details:
We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
1: -#(0(x),0(y)) -> c_10(-#(x,y))
4: -#(1(x),1(y)) -> c_13(-#(x,y))
The strictly oriented rules are moved into the weak component.
***** Step 1.b:7.b:3.a:4.a:1: NaturalPI WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
- Weak DPs:
wb#(n(x,y,z)) -> c_39(-#(size(y),size(z)),-#(size(z),size(y)),wb#(y),wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/4}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
NaturalPI {shape = Mixed 2, restrict = Restrict, 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 polynomial interpretation of kind constructor-based(mixed(2)):
The following argument positions are considered usable:
uargs(c_10) = {1},
uargs(c_11) = {1,2},
uargs(c_12) = {1},
uargs(c_13) = {1},
uargs(c_39) = {1,2,3,4}
Following symbols are considered usable:
{+,0,size,+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#,wb#}
TcT has computed the following interpretation:
p(#) = 0
p(+) = x1 + x2
p(-) = 0
p(0) = 1 + x1
p(1) = 1 + x1
p(and) = 0
p(bs) = 0
p(false) = 0
p(ge) = 0
p(if) = 0
p(l) = 1
p(max) = 0
p(min) = 0
p(n) = 1 + x1 + x2 + x3
p(not) = 0
p(size) = x1
p(true) = 0
p(val) = 0
p(wb) = 0
p(+#) = 0
p(-#) = x2
p(0#) = 0
p(and#) = 0
p(bs#) = 0
p(ge#) = 0
p(if#) = 0
p(max#) = 0
p(min#) = 0
p(not#) = 0
p(size#) = 0
p(val#) = 0
p(wb#) = 1 + x1^2
p(c_1) = 0
p(c_2) = 0
p(c_3) = 0
p(c_4) = 0
p(c_5) = 0
p(c_6) = 0
p(c_7) = 0
p(c_8) = 0
p(c_9) = 0
p(c_10) = x1
p(c_11) = x1 + x2
p(c_12) = 1 + x1
p(c_13) = x1
p(c_14) = 0
p(c_15) = 0
p(c_16) = 0
p(c_17) = 0
p(c_18) = 0
p(c_19) = 0
p(c_20) = 0
p(c_21) = 0
p(c_22) = 0
p(c_23) = 0
p(c_24) = 0
p(c_25) = 0
p(c_26) = 0
p(c_27) = 0
p(c_28) = 0
p(c_29) = 0
p(c_30) = 0
p(c_31) = 0
p(c_32) = 0
p(c_33) = 0
p(c_34) = 0
p(c_35) = 0
p(c_36) = 0
p(c_37) = 0
p(c_38) = 0
p(c_39) = x1 + x2 + x3 + x4
Following rules are strictly oriented:
-#(0(x),0(y)) = 1 + y
> y
= c_10(-#(x,y))
-#(1(x),1(y)) = 1 + y
> y
= c_13(-#(x,y))
Following rules are (at-least) weakly oriented:
-#(0(x),1(y)) = 1 + y
>= 1 + y
= c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) = 1 + y
>= 1 + y
= c_12(-#(x,y))
wb#(n(x,y,z)) = 2 + 2*x + 2*x*y + 2*x*z + x^2 + 2*y + 2*y*z + y^2 + 2*z + z^2
>= 2 + y + y^2 + z + z^2
= c_39(-#(size(y),size(z)),-#(size(z),size(y)),wb#(y),wb#(z))
+(x,#()) = x
>= x
= x
+(x,+(y,z)) = x + y + z
>= x + y + z
= +(+(x,y),z)
+(#(),x) = x
>= x
= x
+(0(x),0(y)) = 2 + x + y
>= 1 + x + y
= 0(+(x,y))
+(0(x),1(y)) = 2 + x + y
>= 1 + x + y
= 1(+(x,y))
+(1(x),0(y)) = 2 + x + y
>= 1 + x + y
= 1(+(x,y))
+(1(x),1(y)) = 2 + x + y
>= 2 + x + y
= 0(+(+(x,y),1(#())))
0(#()) = 1
>= 0
= #()
size(l(x)) = 1
>= 1
= 1(#())
size(n(x,y,z)) = 1 + x + y + z
>= 1 + x + y
= +(+(size(x),size(y)),1(#()))
***** Step 1.b:7.b:3.a:4.a:2: Assumption WORST_CASE(?,O(1))
+ Considered Problem:
- Strict DPs:
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
- Weak DPs:
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
wb#(n(x,y,z)) -> c_39(-#(size(y),size(z)),-#(size(z),size(y)),wb#(y),wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/4}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
+ Details:
()
***** Step 1.b:7.b:3.a:4.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
- Weak DPs:
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
wb#(n(x,y,z)) -> c_39(-#(size(y),size(z)),-#(size(z),size(y)),wb#(y),wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/4}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}}
+ Details:
We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
2: -#(1(x),0(y)) -> c_12(-#(x,y))
The strictly oriented rules are moved into the weak component.
****** Step 1.b:7.b:3.a:4.b:1.a:1: NaturalPI WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
- Weak DPs:
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
wb#(n(x,y,z)) -> c_39(-#(size(y),size(z)),-#(size(z),size(y)),wb#(y),wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/4}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
NaturalPI {shape = Mixed 2, restrict = Restrict, 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 polynomial interpretation of kind constructor-based(mixed(2)):
The following argument positions are considered usable:
uargs(c_10) = {1},
uargs(c_11) = {1,2},
uargs(c_12) = {1},
uargs(c_13) = {1},
uargs(c_39) = {1,2,3,4}
Following symbols are considered usable:
{+,0,size,+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#,wb#}
TcT has computed the following interpretation:
p(#) = 0
p(+) = x1 + x2
p(-) = 0
p(0) = 1 + x1
p(1) = 1 + x1
p(and) = 0
p(bs) = 0
p(false) = 0
p(ge) = 0
p(if) = 0
p(l) = 1
p(max) = 0
p(min) = 0
p(n) = 1 + x1 + x2 + x3
p(not) = 0
p(size) = x1
p(true) = 0
p(val) = 0
p(wb) = 0
p(+#) = 0
p(-#) = x2
p(0#) = 0
p(and#) = 0
p(bs#) = 0
p(ge#) = 0
p(if#) = 0
p(max#) = 0
p(min#) = 0
p(not#) = 0
p(size#) = 0
p(val#) = 0
p(wb#) = x1^2
p(c_1) = 0
p(c_2) = 0
p(c_3) = 0
p(c_4) = 0
p(c_5) = 0
p(c_6) = 0
p(c_7) = 0
p(c_8) = 0
p(c_9) = 0
p(c_10) = 1 + x1
p(c_11) = x1 + x2
p(c_12) = x1
p(c_13) = 1 + x1
p(c_14) = 0
p(c_15) = 0
p(c_16) = 0
p(c_17) = 0
p(c_18) = 0
p(c_19) = 0
p(c_20) = 0
p(c_21) = 0
p(c_22) = 0
p(c_23) = 0
p(c_24) = 0
p(c_25) = 0
p(c_26) = 0
p(c_27) = 0
p(c_28) = 0
p(c_29) = 0
p(c_30) = 0
p(c_31) = 0
p(c_32) = 0
p(c_33) = 0
p(c_34) = 0
p(c_35) = 0
p(c_36) = 0
p(c_37) = 0
p(c_38) = 0
p(c_39) = 1 + x1 + x2 + x3 + x4
Following rules are strictly oriented:
-#(1(x),0(y)) = 1 + y
> y
= c_12(-#(x,y))
Following rules are (at-least) weakly oriented:
-#(0(x),0(y)) = 1 + y
>= 1 + y
= c_10(-#(x,y))
-#(0(x),1(y)) = 1 + y
>= 1 + y
= c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),1(y)) = 1 + y
>= 1 + y
= c_13(-#(x,y))
wb#(n(x,y,z)) = 1 + 2*x + 2*x*y + 2*x*z + x^2 + 2*y + 2*y*z + y^2 + 2*z + z^2
>= 1 + y + y^2 + z + z^2
= c_39(-#(size(y),size(z)),-#(size(z),size(y)),wb#(y),wb#(z))
+(x,#()) = x
>= x
= x
+(x,+(y,z)) = x + y + z
>= x + y + z
= +(+(x,y),z)
+(#(),x) = x
>= x
= x
+(0(x),0(y)) = 2 + x + y
>= 1 + x + y
= 0(+(x,y))
+(0(x),1(y)) = 2 + x + y
>= 1 + x + y
= 1(+(x,y))
+(1(x),0(y)) = 2 + x + y
>= 1 + x + y
= 1(+(x,y))
+(1(x),1(y)) = 2 + x + y
>= 2 + x + y
= 0(+(+(x,y),1(#())))
0(#()) = 1
>= 0
= #()
size(l(x)) = 1
>= 1
= 1(#())
size(n(x,y,z)) = 1 + x + y + z
>= 1 + x + y
= +(+(size(x),size(y)),1(#()))
****** Step 1.b:7.b:3.a:4.b:1.a:2: Assumption WORST_CASE(?,O(1))
+ Considered Problem:
- Strict DPs:
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
- Weak DPs:
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
wb#(n(x,y,z)) -> c_39(-#(size(y),size(z)),-#(size(z),size(y)),wb#(y),wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/4}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
+ Details:
()
****** Step 1.b:7.b:3.a:4.b:1.b:1: PredecessorEstimationCP WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
- Weak DPs:
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
wb#(n(x,y,z)) -> c_39(-#(size(y),size(z)),-#(size(z),size(y)),wb#(y),wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/4}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}}
+ Details:
We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
1: -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
The strictly oriented rules are moved into the weak component.
******* Step 1.b:7.b:3.a:4.b:1.b:1.a:1: NaturalPI WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
- Weak DPs:
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
wb#(n(x,y,z)) -> c_39(-#(size(y),size(z)),-#(size(z),size(y)),wb#(y),wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/4}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
NaturalPI {shape = Mixed 2, restrict = Restrict, 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 polynomial interpretation of kind constructor-based(mixed(2)):
The following argument positions are considered usable:
uargs(c_10) = {1},
uargs(c_11) = {1,2},
uargs(c_12) = {1},
uargs(c_13) = {1},
uargs(c_39) = {1,2,3,4}
Following symbols are considered usable:
{+,-,0,size,+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#,wb#}
TcT has computed the following interpretation:
p(#) = 0
p(+) = x1 + x2
p(-) = x1
p(0) = 1 + x1
p(1) = 1 + x1
p(and) = 0
p(bs) = 0
p(false) = 0
p(ge) = 0
p(if) = 0
p(l) = 1
p(max) = 0
p(min) = 0
p(n) = 1 + x1 + x2 + x3
p(not) = 0
p(size) = x1
p(true) = 0
p(val) = 0
p(wb) = 0
p(+#) = 0
p(-#) = x1*x2
p(0#) = 0
p(and#) = 0
p(bs#) = 0
p(ge#) = 0
p(if#) = 0
p(max#) = 0
p(min#) = 0
p(not#) = 0
p(size#) = 0
p(val#) = 0
p(wb#) = x1^2
p(c_1) = 0
p(c_2) = 0
p(c_3) = 0
p(c_4) = 0
p(c_5) = 0
p(c_6) = 0
p(c_7) = 0
p(c_8) = 0
p(c_9) = 0
p(c_10) = 1 + x1
p(c_11) = x1 + x2
p(c_12) = x1
p(c_13) = x1
p(c_14) = 0
p(c_15) = 0
p(c_16) = 0
p(c_17) = 0
p(c_18) = 0
p(c_19) = 0
p(c_20) = 0
p(c_21) = 0
p(c_22) = 0
p(c_23) = 0
p(c_24) = 0
p(c_25) = 0
p(c_26) = 0
p(c_27) = 0
p(c_28) = 0
p(c_29) = 0
p(c_30) = 0
p(c_31) = 0
p(c_32) = 0
p(c_33) = 0
p(c_34) = 0
p(c_35) = 0
p(c_36) = 0
p(c_37) = 0
p(c_38) = 0
p(c_39) = 1 + x1 + x2 + x3 + x4
Following rules are strictly oriented:
-#(0(x),1(y)) = 1 + x + x*y + y
> x + x*y
= c_11(-#(-(x,y),1(#())),-#(x,y))
Following rules are (at-least) weakly oriented:
-#(0(x),0(y)) = 1 + x + x*y + y
>= 1 + x*y
= c_10(-#(x,y))
-#(1(x),0(y)) = 1 + x + x*y + y
>= x*y
= c_12(-#(x,y))
-#(1(x),1(y)) = 1 + x + x*y + y
>= x*y
= c_13(-#(x,y))
wb#(n(x,y,z)) = 1 + 2*x + 2*x*y + 2*x*z + x^2 + 2*y + 2*y*z + y^2 + 2*z + z^2
>= 1 + 2*y*z + y^2 + z^2
= c_39(-#(size(y),size(z)),-#(size(z),size(y)),wb#(y),wb#(z))
+(x,#()) = x
>= x
= x
+(x,+(y,z)) = x + y + z
>= x + y + z
= +(+(x,y),z)
+(#(),x) = x
>= x
= x
+(0(x),0(y)) = 2 + x + y
>= 1 + x + y
= 0(+(x,y))
+(0(x),1(y)) = 2 + x + y
>= 1 + x + y
= 1(+(x,y))
+(1(x),0(y)) = 2 + x + y
>= 1 + x + y
= 1(+(x,y))
+(1(x),1(y)) = 2 + x + y
>= 2 + x + y
= 0(+(+(x,y),1(#())))
-(x,#()) = x
>= x
= x
-(#(),x) = 0
>= 0
= #()
-(0(x),0(y)) = 1 + x
>= 1 + x
= 0(-(x,y))
-(0(x),1(y)) = 1 + x
>= 1 + x
= 1(-(-(x,y),1(#())))
-(1(x),0(y)) = 1 + x
>= 1 + x
= 1(-(x,y))
-(1(x),1(y)) = 1 + x
>= 1 + x
= 0(-(x,y))
0(#()) = 1
>= 0
= #()
size(l(x)) = 1
>= 1
= 1(#())
size(n(x,y,z)) = 1 + x + y + z
>= 1 + x + y
= +(+(size(x),size(y)),1(#()))
******* Step 1.b:7.b:3.a:4.b:1.b:1.a:2: Assumption WORST_CASE(?,O(1))
+ Considered Problem:
- Weak DPs:
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
wb#(n(x,y,z)) -> c_39(-#(size(y),size(z)),-#(size(z),size(y)),wb#(y),wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/4}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
+ Details:
()
******* Step 1.b:7.b:3.a:4.b:1.b:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1))
+ Considered Problem:
- Weak DPs:
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
wb#(n(x,y,z)) -> c_39(-#(size(y),size(z)),-#(size(z),size(y)),wb#(y),wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/4}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
RemoveWeakSuffixes
+ Details:
Consider the dependency graph
1:W:-#(0(x),0(y)) -> c_10(-#(x,y))
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_1 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_1 -#(0(x),0(y)) -> c_10(-#(x,y)):1
2:W:-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-->_2 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_2 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_2 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_2 -#(0(x),0(y)) -> c_10(-#(x,y)):1
3:W:-#(1(x),0(y)) -> c_12(-#(x,y))
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_1 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_1 -#(0(x),0(y)) -> c_10(-#(x,y)):1
4:W:-#(1(x),1(y)) -> c_13(-#(x,y))
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_1 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_1 -#(0(x),0(y)) -> c_10(-#(x,y)):1
5:W:wb#(n(x,y,z)) -> c_39(-#(size(y),size(z)),-#(size(z),size(y)),wb#(y),wb#(z))
-->_4 wb#(n(x,y,z)) -> c_39(-#(size(y),size(z)),-#(size(z),size(y)),wb#(y),wb#(z)):5
-->_3 wb#(n(x,y,z)) -> c_39(-#(size(y),size(z)),-#(size(z),size(y)),wb#(y),wb#(z)):5
-->_2 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):4
-->_2 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_1 -#(1(x),0(y)) -> c_12(-#(x,y)):3
-->_2 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):2
-->_2 -#(0(x),0(y)) -> c_10(-#(x,y)):1
-->_1 -#(0(x),0(y)) -> c_10(-#(x,y)):1
The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
5: wb#(n(x,y,z)) -> c_39(-#(size(y),size(z)),-#(size(z),size(y)),wb#(y),wb#(z))
1: -#(0(x),0(y)) -> c_10(-#(x,y))
4: -#(1(x),1(y)) -> c_13(-#(x,y))
3: -#(1(x),0(y)) -> c_12(-#(x,y))
2: -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
******* Step 1.b:7.b:3.a:4.b:1.b:1.b:2: EmptyProcessor WORST_CASE(?,O(1))
+ Considered Problem:
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/4}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
EmptyProcessor
+ Details:
The problem is already closed. The intended complexity is O(1).
**** Step 1.b:7.b:3.b:1: RemoveWeakSuffixes WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
min#(n(x,y,z)) -> c_31(min#(y))
size#(n(x,y,z)) -> c_35(size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
- Weak DPs:
-#(0(x),0(y)) -> c_10(-#(x,y))
-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-#(1(x),0(y)) -> c_12(-#(x,y))
-#(1(x),1(y)) -> c_13(-#(x,y))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/13}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
RemoveWeakSuffixes
+ Details:
Consider the dependency graph
1:S:bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
-->_4 min#(n(x,y,z)) -> c_31(min#(y)):8
-->_2 max#(n(x,y,z)) -> c_29(max#(z)):7
-->_3 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_3 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_3 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_3 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_3 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
-->_6 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z)):1
-->_5 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z)):1
2:S:ge#(#(),0(x)) -> c_20(ge#(#(),x))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
3:S:ge#(0(x),0(y)) -> c_22(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
4:S:ge#(0(x),1(y)) -> c_23(ge#(y,x))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
5:S:ge#(1(x),0(y)) -> c_24(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
6:S:ge#(1(x),1(y)) -> c_25(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
7:S:max#(n(x,y,z)) -> c_29(max#(z))
-->_1 max#(n(x,y,z)) -> c_29(max#(z)):7
8:S:min#(n(x,y,z)) -> c_31(min#(y))
-->_1 min#(n(x,y,z)) -> c_31(min#(y)):8
9:S:size#(n(x,y,z)) -> c_35(size#(x),size#(y))
-->_2 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):9
-->_1 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):9
10:S:wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
-->_9 -#(1(x),1(y)) -> c_13(-#(x,y)):14
-->_5 -#(1(x),1(y)) -> c_13(-#(x,y)):14
-->_9 -#(1(x),0(y)) -> c_12(-#(x,y)):13
-->_5 -#(1(x),0(y)) -> c_12(-#(x,y)):13
-->_9 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):12
-->_5 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):12
-->_9 -#(0(x),0(y)) -> c_10(-#(x,y)):11
-->_5 -#(0(x),0(y)) -> c_10(-#(x,y)):11
-->_13 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z)):10
-->_12 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z)):10
-->_11 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):9
-->_10 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):9
-->_7 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):9
-->_6 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):9
-->_3 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):9
-->_2 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):9
-->_8 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_4 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_8 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_4 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
11:W:-#(0(x),0(y)) -> c_10(-#(x,y))
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):14
-->_1 -#(1(x),0(y)) -> c_12(-#(x,y)):13
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):12
-->_1 -#(0(x),0(y)) -> c_10(-#(x,y)):11
12:W:-#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
-->_2 -#(1(x),1(y)) -> c_13(-#(x,y)):14
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):14
-->_2 -#(1(x),0(y)) -> c_12(-#(x,y)):13
-->_2 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):12
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):12
-->_2 -#(0(x),0(y)) -> c_10(-#(x,y)):11
13:W:-#(1(x),0(y)) -> c_12(-#(x,y))
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):14
-->_1 -#(1(x),0(y)) -> c_12(-#(x,y)):13
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):12
-->_1 -#(0(x),0(y)) -> c_10(-#(x,y)):11
14:W:-#(1(x),1(y)) -> c_13(-#(x,y))
-->_1 -#(1(x),1(y)) -> c_13(-#(x,y)):14
-->_1 -#(1(x),0(y)) -> c_12(-#(x,y)):13
-->_1 -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y)):12
-->_1 -#(0(x),0(y)) -> c_10(-#(x,y)):11
The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
14: -#(1(x),1(y)) -> c_13(-#(x,y))
13: -#(1(x),0(y)) -> c_12(-#(x,y))
12: -#(0(x),1(y)) -> c_11(-#(-(x,y),1(#())),-#(x,y))
11: -#(0(x),0(y)) -> c_10(-#(x,y))
**** Step 1.b:7.b:3.b:2: SimplifyRHS WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
min#(n(x,y,z)) -> c_31(min#(y))
size#(n(x,y,z)) -> c_35(size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/13}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
SimplifyRHS
+ Details:
Consider the dependency graph
1:S:bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
-->_4 min#(n(x,y,z)) -> c_31(min#(y)):8
-->_2 max#(n(x,y,z)) -> c_29(max#(z)):7
-->_3 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_3 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_3 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_3 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_3 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
-->_6 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z)):1
-->_5 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z)):1
2:S:ge#(#(),0(x)) -> c_20(ge#(#(),x))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
3:S:ge#(0(x),0(y)) -> c_22(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
4:S:ge#(0(x),1(y)) -> c_23(ge#(y,x))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
5:S:ge#(1(x),0(y)) -> c_24(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
6:S:ge#(1(x),1(y)) -> c_25(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
7:S:max#(n(x,y,z)) -> c_29(max#(z))
-->_1 max#(n(x,y,z)) -> c_29(max#(z)):7
8:S:min#(n(x,y,z)) -> c_31(min#(y))
-->_1 min#(n(x,y,z)) -> c_31(min#(y)):8
9:S:size#(n(x,y,z)) -> c_35(size#(x),size#(y))
-->_2 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):9
-->_1 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):9
10:S:wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
-->_13 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z)):10
-->_12 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,-#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,-#(size(z),size(y))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z)):10
-->_11 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):9
-->_10 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):9
-->_7 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):9
-->_6 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):9
-->_3 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):9
-->_2 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):9
-->_8 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_4 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_8 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_4 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified:
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
**** Step 1.b:7.b:3.b:3: Decompose WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
min#(n(x,y,z)) -> c_31(min#(y))
size#(n(x,y,z)) -> c_35(size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/11}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ 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:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
min#(n(x,y,z)) -> c_31(min#(y))
- Weak DPs:
size#(n(x,y,z)) -> c_35(size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0
,c_4/1,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0
,c_20/1,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0
,c_35/2,c_36/0,c_37/0,c_38/0,c_39/11}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
Problem (S)
- Strict DPs:
size#(n(x,y,z)) -> c_35(size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
- Weak DPs:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
min#(n(x,y,z)) -> c_31(min#(y))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0
,c_4/1,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0
,c_20/1,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0
,c_35/2,c_36/0,c_37/0,c_38/0,c_39/11}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
***** Step 1.b:7.b:3.b:3.a:1: RemoveWeakSuffixes WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
min#(n(x,y,z)) -> c_31(min#(y))
- Weak DPs:
size#(n(x,y,z)) -> c_35(size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/11}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
RemoveWeakSuffixes
+ Details:
Consider the dependency graph
1:S:bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
-->_4 min#(n(x,y,z)) -> c_31(min#(y)):8
-->_2 max#(n(x,y,z)) -> c_29(max#(z)):7
-->_3 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_3 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_3 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_3 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_3 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
-->_6 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z)):1
-->_5 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z)):1
2:S:ge#(#(),0(x)) -> c_20(ge#(#(),x))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
3:S:ge#(0(x),0(y)) -> c_22(ge#(x,y))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
4:S:ge#(0(x),1(y)) -> c_23(ge#(y,x))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
5:S:ge#(1(x),0(y)) -> c_24(ge#(x,y))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
6:S:ge#(1(x),1(y)) -> c_25(ge#(x,y))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
7:S:max#(n(x,y,z)) -> c_29(max#(z))
-->_1 max#(n(x,y,z)) -> c_29(max#(z)):7
8:S:min#(n(x,y,z)) -> c_31(min#(y))
-->_1 min#(n(x,y,z)) -> c_31(min#(y)):8
9:W:size#(n(x,y,z)) -> c_35(size#(x),size#(y))
-->_2 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):9
-->_1 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):9
10:W:wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_7 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_4 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_7 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_4 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_9 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):9
-->_8 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):9
-->_6 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):9
-->_5 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):9
-->_3 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):9
-->_2 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):9
-->_11 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z)):10
-->_10 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z)):10
The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
9: size#(n(x,y,z)) -> c_35(size#(x),size#(y))
***** Step 1.b:7.b:3.b:3.a:2: SimplifyRHS WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
min#(n(x,y,z)) -> c_31(min#(y))
- Weak DPs:
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/11}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
SimplifyRHS
+ Details:
Consider the dependency graph
1:S:bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
-->_4 min#(n(x,y,z)) -> c_31(min#(y)):8
-->_2 max#(n(x,y,z)) -> c_29(max#(z)):7
-->_3 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_3 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_3 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_3 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_3 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
-->_6 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z)):1
-->_5 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z)):1
2:S:ge#(#(),0(x)) -> c_20(ge#(#(),x))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
3:S:ge#(0(x),0(y)) -> c_22(ge#(x,y))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
4:S:ge#(0(x),1(y)) -> c_23(ge#(y,x))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
5:S:ge#(1(x),0(y)) -> c_24(ge#(x,y))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
6:S:ge#(1(x),1(y)) -> c_25(ge#(x,y))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
7:S:max#(n(x,y,z)) -> c_29(max#(z))
-->_1 max#(n(x,y,z)) -> c_29(max#(z)):7
8:S:min#(n(x,y,z)) -> c_31(min#(y))
-->_1 min#(n(x,y,z)) -> c_31(min#(y)):8
10:W:wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_7 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_4 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_7 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_4 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_11 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z)):10
-->_10 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z)):10
Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified:
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z))
***** Step 1.b:7.b:3.b:3.a:3: PredecessorEstimationCP WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
min#(n(x,y,z)) -> c_31(min#(y))
- Weak DPs:
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/5}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}}
+ Details:
We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
8: min#(n(x,y,z)) -> c_31(min#(y))
The strictly oriented rules are moved into the weak component.
****** Step 1.b:7.b:3.b:3.a:3.a:1: NaturalPI WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
min#(n(x,y,z)) -> c_31(min#(y))
- Weak DPs:
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/5}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
NaturalPI {shape = Mixed 2, restrict = Restrict, 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 polynomial interpretation of kind constructor-based(mixed(2)):
The following argument positions are considered usable:
uargs(c_18) = {1,2,3,4,5,6},
uargs(c_20) = {1},
uargs(c_22) = {1},
uargs(c_23) = {1},
uargs(c_24) = {1},
uargs(c_25) = {1},
uargs(c_29) = {1},
uargs(c_31) = {1},
uargs(c_39) = {1,2,3,4,5}
Following symbols are considered usable:
{+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#,wb#}
TcT has computed the following interpretation:
p(#) = 1
p(+) = 0
p(-) = 0
p(0) = 1
p(1) = 0
p(and) = 0
p(bs) = 0
p(false) = 0
p(ge) = 0
p(if) = 0
p(l) = 0
p(max) = 0
p(min) = x1
p(n) = 1 + x2 + x3
p(not) = 0
p(size) = 0
p(true) = 0
p(val) = 0
p(wb) = 0
p(+#) = 0
p(-#) = 0
p(0#) = 0
p(and#) = 0
p(bs#) = 1 + x1 + x1^2
p(ge#) = 0
p(if#) = 0
p(max#) = 1
p(min#) = x1
p(not#) = 0
p(size#) = 0
p(val#) = 0
p(wb#) = x1 + x1^2
p(c_1) = 0
p(c_2) = 0
p(c_3) = 0
p(c_4) = 0
p(c_5) = 0
p(c_6) = 0
p(c_7) = 0
p(c_8) = 0
p(c_9) = 0
p(c_10) = 0
p(c_11) = 0
p(c_12) = 0
p(c_13) = 0
p(c_14) = 0
p(c_15) = 0
p(c_16) = 0
p(c_17) = 0
p(c_18) = x1 + x2 + x3 + x4 + x5 + x6
p(c_19) = 0
p(c_20) = x1
p(c_21) = 0
p(c_22) = x1
p(c_23) = x1
p(c_24) = x1
p(c_25) = x1
p(c_26) = 0
p(c_27) = 0
p(c_28) = 0
p(c_29) = x1
p(c_30) = 0
p(c_31) = x1
p(c_32) = 0
p(c_33) = 0
p(c_34) = 0
p(c_35) = 0
p(c_36) = 0
p(c_37) = 0
p(c_38) = 0
p(c_39) = 1 + x1 + x2 + x3 + x4 + x5
Following rules are strictly oriented:
min#(n(x,y,z)) = 1 + y + z
> y
= c_31(min#(y))
Following rules are (at-least) weakly oriented:
bs#(n(x,y,z)) = 3 + 3*y + 2*y*z + y^2 + 3*z + z^2
>= 3 + y + y^2 + 2*z + z^2
= c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) = 0
>= 0
= c_20(ge#(#(),x))
ge#(0(x),0(y)) = 0
>= 0
= c_22(ge#(x,y))
ge#(0(x),1(y)) = 0
>= 0
= c_23(ge#(y,x))
ge#(1(x),0(y)) = 0
>= 0
= c_24(ge#(x,y))
ge#(1(x),1(y)) = 0
>= 0
= c_25(ge#(x,y))
max#(n(x,y,z)) = 1
>= 1
= c_29(max#(z))
wb#(n(x,y,z)) = 2 + 3*y + 2*y*z + y^2 + 3*z + z^2
>= 1 + y + y^2 + z + z^2
= c_39(ge#(size(y),size(z)),ge#(1(#()),-(size(y),size(z))),ge#(1(#()),-(size(z),size(y))),wb#(y),wb#(z))
****** Step 1.b:7.b:3.b:3.a:3.a:2: Assumption WORST_CASE(?,O(1))
+ Considered Problem:
- Strict DPs:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
- Weak DPs:
min#(n(x,y,z)) -> c_31(min#(y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/5}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
+ Details:
()
****** Step 1.b:7.b:3.b:3.a:3.b:1: RemoveWeakSuffixes WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
- Weak DPs:
min#(n(x,y,z)) -> c_31(min#(y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/5}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
RemoveWeakSuffixes
+ Details:
Consider the dependency graph
1:S:bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
-->_4 min#(n(x,y,z)) -> c_31(min#(y)):8
-->_2 max#(n(x,y,z)) -> c_29(max#(z)):7
-->_3 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_3 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_3 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_3 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_3 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
-->_6 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z)):1
-->_5 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z)):1
2:S:ge#(#(),0(x)) -> c_20(ge#(#(),x))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
3:S:ge#(0(x),0(y)) -> c_22(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
4:S:ge#(0(x),1(y)) -> c_23(ge#(y,x))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
5:S:ge#(1(x),0(y)) -> c_24(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
6:S:ge#(1(x),1(y)) -> c_25(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
7:S:max#(n(x,y,z)) -> c_29(max#(z))
-->_1 max#(n(x,y,z)) -> c_29(max#(z)):7
8:W:min#(n(x,y,z)) -> c_31(min#(y))
-->_1 min#(n(x,y,z)) -> c_31(min#(y)):8
9:W:wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z))
-->_5 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z)):9
-->_4 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z)):9
-->_3 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_2 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_3 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_2 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
8: min#(n(x,y,z)) -> c_31(min#(y))
****** Step 1.b:7.b:3.b:3.a:3.b:2: SimplifyRHS WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
- Weak DPs:
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/5}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
SimplifyRHS
+ Details:
Consider the dependency graph
1:S:bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
-->_2 max#(n(x,y,z)) -> c_29(max#(z)):7
-->_3 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_3 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_3 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_3 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_3 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
-->_6 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z)):1
-->_5 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z)):1
2:S:ge#(#(),0(x)) -> c_20(ge#(#(),x))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
3:S:ge#(0(x),0(y)) -> c_22(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
4:S:ge#(0(x),1(y)) -> c_23(ge#(y,x))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
5:S:ge#(1(x),0(y)) -> c_24(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
6:S:ge#(1(x),1(y)) -> c_25(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
7:S:max#(n(x,y,z)) -> c_29(max#(z))
-->_1 max#(n(x,y,z)) -> c_29(max#(z)):7
9:W:wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z))
-->_5 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z)):9
-->_4 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z)):9
-->_3 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_2 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_3 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_2 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),bs#(y),bs#(z))
****** Step 1.b:7.b:3.b:3.a:3.b:3: PredecessorEstimationCP WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
- Weak DPs:
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/5,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/5}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}}
+ Details:
We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
1: bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),bs#(y),bs#(z))
7: max#(n(x,y,z)) -> c_29(max#(z))
The strictly oriented rules are moved into the weak component.
******* Step 1.b:7.b:3.b:3.a:3.b:3.a:1: NaturalPI WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
- Weak DPs:
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/5,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/5}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
NaturalPI {shape = Mixed 2, restrict = Restrict, 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 polynomial interpretation of kind constructor-based(mixed(2)):
The following argument positions are considered usable:
uargs(c_18) = {1,2,3,4,5},
uargs(c_20) = {1},
uargs(c_22) = {1},
uargs(c_23) = {1},
uargs(c_24) = {1},
uargs(c_25) = {1},
uargs(c_29) = {1},
uargs(c_39) = {1,2,3,4,5}
Following symbols are considered usable:
{+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#,wb#}
TcT has computed the following interpretation:
p(#) = 0
p(+) = x2
p(-) = x1
p(0) = 1 + x1
p(1) = x1
p(and) = 0
p(bs) = 0
p(false) = 0
p(ge) = 0
p(if) = 0
p(l) = 0
p(max) = 1
p(min) = 0
p(n) = 1 + x2 + x3
p(not) = 0
p(size) = 0
p(true) = 0
p(val) = 0
p(wb) = 0
p(+#) = 0
p(-#) = 0
p(0#) = 0
p(and#) = 0
p(bs#) = x1^2
p(ge#) = 0
p(if#) = 0
p(max#) = x1
p(min#) = 0
p(not#) = 0
p(size#) = 0
p(val#) = 0
p(wb#) = x1^2
p(c_1) = 0
p(c_2) = 0
p(c_3) = 0
p(c_4) = 0
p(c_5) = 0
p(c_6) = 0
p(c_7) = 0
p(c_8) = 0
p(c_9) = 0
p(c_10) = 0
p(c_11) = 0
p(c_12) = 0
p(c_13) = 0
p(c_14) = 0
p(c_15) = 0
p(c_16) = 0
p(c_17) = 0
p(c_18) = x1 + x2 + x3 + x4 + x5
p(c_19) = 0
p(c_20) = x1
p(c_21) = 0
p(c_22) = x1
p(c_23) = x1
p(c_24) = x1
p(c_25) = x1
p(c_26) = 0
p(c_27) = 0
p(c_28) = 0
p(c_29) = x1
p(c_30) = 0
p(c_31) = 0
p(c_32) = 0
p(c_33) = 0
p(c_34) = 0
p(c_35) = 0
p(c_36) = 0
p(c_37) = 0
p(c_38) = 0
p(c_39) = 1 + x1 + x2 + x3 + x4 + x5
Following rules are strictly oriented:
bs#(n(x,y,z)) = 1 + 2*y + 2*y*z + y^2 + 2*z + z^2
> y + y^2 + z^2
= c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),bs#(y),bs#(z))
max#(n(x,y,z)) = 1 + y + z
> z
= c_29(max#(z))
Following rules are (at-least) weakly oriented:
ge#(#(),0(x)) = 0
>= 0
= c_20(ge#(#(),x))
ge#(0(x),0(y)) = 0
>= 0
= c_22(ge#(x,y))
ge#(0(x),1(y)) = 0
>= 0
= c_23(ge#(y,x))
ge#(1(x),0(y)) = 0
>= 0
= c_24(ge#(x,y))
ge#(1(x),1(y)) = 0
>= 0
= c_25(ge#(x,y))
wb#(n(x,y,z)) = 1 + 2*y + 2*y*z + y^2 + 2*z + z^2
>= 1 + y^2 + z^2
= c_39(ge#(size(y),size(z)),ge#(1(#()),-(size(y),size(z))),ge#(1(#()),-(size(z),size(y))),wb#(y),wb#(z))
******* Step 1.b:7.b:3.b:3.a:3.b:3.a:2: Assumption WORST_CASE(?,O(1))
+ Considered Problem:
- Strict DPs:
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
- Weak DPs:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),bs#(y),bs#(z))
max#(n(x,y,z)) -> c_29(max#(z))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/5,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/5}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
+ Details:
()
******* Step 1.b:7.b:3.b:3.a:3.b:3.b:1: RemoveWeakSuffixes WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
- Weak DPs:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),bs#(y),bs#(z))
max#(n(x,y,z)) -> c_29(max#(z))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/5,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/5}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
RemoveWeakSuffixes
+ Details:
Consider the dependency graph
1:S:ge#(#(),0(x)) -> c_20(ge#(#(),x))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):1
2:S:ge#(0(x),0(y)) -> c_22(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):5
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):4
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):3
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):2
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):1
3:S:ge#(0(x),1(y)) -> c_23(ge#(y,x))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):5
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):4
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):3
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):2
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):1
4:S:ge#(1(x),0(y)) -> c_24(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):5
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):4
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):3
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):2
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):1
5:S:ge#(1(x),1(y)) -> c_25(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):5
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):4
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):3
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):2
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):1
6:W:bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),bs#(y),bs#(z))
-->_2 max#(n(x,y,z)) -> c_29(max#(z)):7
-->_5 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),bs#(y),bs#(z)):6
-->_4 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),bs#(y),bs#(z)):6
-->_3 ge#(1(x),1(y)) -> c_25(ge#(x,y)):5
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):5
-->_3 ge#(1(x),0(y)) -> c_24(ge#(x,y)):4
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):4
-->_3 ge#(0(x),1(y)) -> c_23(ge#(y,x)):3
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):3
-->_3 ge#(0(x),0(y)) -> c_22(ge#(x,y)):2
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):2
-->_3 ge#(#(),0(x)) -> c_20(ge#(#(),x)):1
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):1
7:W:max#(n(x,y,z)) -> c_29(max#(z))
-->_1 max#(n(x,y,z)) -> c_29(max#(z)):7
8:W:wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z))
-->_5 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z)):8
-->_4 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z)):8
-->_3 ge#(1(x),1(y)) -> c_25(ge#(x,y)):5
-->_2 ge#(1(x),1(y)) -> c_25(ge#(x,y)):5
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):5
-->_3 ge#(1(x),0(y)) -> c_24(ge#(x,y)):4
-->_2 ge#(1(x),0(y)) -> c_24(ge#(x,y)):4
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):4
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):3
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):2
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):1
The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
7: max#(n(x,y,z)) -> c_29(max#(z))
******* Step 1.b:7.b:3.b:3.a:3.b:3.b:2: SimplifyRHS WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
- Weak DPs:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),bs#(y),bs#(z))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/5,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/5}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
SimplifyRHS
+ Details:
Consider the dependency graph
1:S:ge#(#(),0(x)) -> c_20(ge#(#(),x))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):1
2:S:ge#(0(x),0(y)) -> c_22(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):5
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):4
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):3
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):2
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):1
3:S:ge#(0(x),1(y)) -> c_23(ge#(y,x))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):5
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):4
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):3
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):2
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):1
4:S:ge#(1(x),0(y)) -> c_24(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):5
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):4
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):3
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):2
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):1
5:S:ge#(1(x),1(y)) -> c_25(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):5
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):4
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):3
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):2
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):1
6:W:bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),bs#(y),bs#(z))
-->_5 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),bs#(y),bs#(z)):6
-->_4 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),bs#(y),bs#(z)):6
-->_3 ge#(1(x),1(y)) -> c_25(ge#(x,y)):5
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):5
-->_3 ge#(1(x),0(y)) -> c_24(ge#(x,y)):4
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):4
-->_3 ge#(0(x),1(y)) -> c_23(ge#(y,x)):3
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):3
-->_3 ge#(0(x),0(y)) -> c_22(ge#(x,y)):2
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):2
-->_3 ge#(#(),0(x)) -> c_20(ge#(#(),x)):1
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):1
8:W:wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z))
-->_5 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z)):8
-->_4 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z)):8
-->_3 ge#(1(x),1(y)) -> c_25(ge#(x,y)):5
-->_2 ge#(1(x),1(y)) -> c_25(ge#(x,y)):5
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):5
-->_3 ge#(1(x),0(y)) -> c_24(ge#(x,y)):4
-->_2 ge#(1(x),0(y)) -> c_24(ge#(x,y)):4
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):4
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):3
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):2
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):1
Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),ge#(min(z),x),bs#(y),bs#(z))
******* Step 1.b:7.b:3.b:3.a:3.b:3.b:3: PredecessorEstimationCP WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
- Weak DPs:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),ge#(min(z),x),bs#(y),bs#(z))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/4,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/5}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}}
+ Details:
We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
1: ge#(#(),0(x)) -> c_20(ge#(#(),x))
2: ge#(0(x),0(y)) -> c_22(ge#(x,y))
3: ge#(0(x),1(y)) -> c_23(ge#(y,x))
4: ge#(1(x),0(y)) -> c_24(ge#(x,y))
5: ge#(1(x),1(y)) -> c_25(ge#(x,y))
The strictly oriented rules are moved into the weak component.
******** Step 1.b:7.b:3.b:3.a:3.b:3.b:3.a:1: NaturalPI WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
- Weak DPs:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),ge#(min(z),x),bs#(y),bs#(z))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/4,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/5}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
NaturalPI {shape = Mixed 2, restrict = Restrict, 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 polynomial interpretation of kind constructor-based(mixed(2)):
The following argument positions are considered usable:
uargs(c_18) = {1,2,3,4},
uargs(c_20) = {1},
uargs(c_22) = {1},
uargs(c_23) = {1},
uargs(c_24) = {1},
uargs(c_25) = {1},
uargs(c_39) = {1,2,3,4,5}
Following symbols are considered usable:
{+,-,0,max,min,size,+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#,wb#}
TcT has computed the following interpretation:
p(#) = 0
p(+) = x1 + x2
p(-) = x1
p(0) = 1 + x1
p(1) = 1 + x1
p(and) = 0
p(bs) = 0
p(false) = 0
p(ge) = 0
p(if) = 0
p(l) = 1 + x1
p(max) = x1
p(min) = x1
p(n) = 1 + x1 + x2 + x3
p(not) = 0
p(size) = x1
p(true) = 0
p(val) = 0
p(wb) = 0
p(+#) = 0
p(-#) = 0
p(0#) = 0
p(and#) = 0
p(bs#) = x1^2
p(ge#) = x1 + x2
p(if#) = 0
p(max#) = 0
p(min#) = 0
p(not#) = 0
p(size#) = 0
p(val#) = 0
p(wb#) = x1 + x1^2
p(c_1) = 0
p(c_2) = 0
p(c_3) = 0
p(c_4) = 0
p(c_5) = 0
p(c_6) = 0
p(c_7) = 0
p(c_8) = 0
p(c_9) = 0
p(c_10) = 0
p(c_11) = 0
p(c_12) = 0
p(c_13) = 0
p(c_14) = 0
p(c_15) = 0
p(c_16) = 0
p(c_17) = 0
p(c_18) = 1 + x1 + x2 + x3 + x4
p(c_19) = 0
p(c_20) = x1
p(c_21) = 0
p(c_22) = x1
p(c_23) = x1
p(c_24) = x1
p(c_25) = x1
p(c_26) = 0
p(c_27) = 0
p(c_28) = 0
p(c_29) = 0
p(c_30) = 0
p(c_31) = 0
p(c_32) = 0
p(c_33) = 0
p(c_34) = 0
p(c_35) = 0
p(c_36) = 0
p(c_37) = 0
p(c_38) = 0
p(c_39) = x1 + x2 + x3 + x4 + x5
Following rules are strictly oriented:
ge#(#(),0(x)) = 1 + x
> x
= c_20(ge#(#(),x))
ge#(0(x),0(y)) = 2 + x + y
> x + y
= c_22(ge#(x,y))
ge#(0(x),1(y)) = 2 + x + y
> x + y
= c_23(ge#(y,x))
ge#(1(x),0(y)) = 2 + x + y
> x + y
= c_24(ge#(x,y))
ge#(1(x),1(y)) = 2 + x + y
> x + y
= c_25(ge#(x,y))
Following rules are (at-least) weakly oriented:
bs#(n(x,y,z)) = 1 + 2*x + 2*x*y + 2*x*z + x^2 + 2*y + 2*y*z + y^2 + 2*z + z^2
>= 1 + 2*x + y + y^2 + z + z^2
= c_18(ge#(x,max(y)),ge#(min(z),x),bs#(y),bs#(z))
wb#(n(x,y,z)) = 2 + 3*x + 2*x*y + 2*x*z + x^2 + 3*y + 2*y*z + y^2 + 3*z + z^2
>= 2 + 3*y + y^2 + 3*z + z^2
= c_39(ge#(size(y),size(z)),ge#(1(#()),-(size(y),size(z))),ge#(1(#()),-(size(z),size(y))),wb#(y),wb#(z))
+(x,#()) = x
>= x
= x
+(x,+(y,z)) = x + y + z
>= x + y + z
= +(+(x,y),z)
+(#(),x) = x
>= x
= x
+(0(x),0(y)) = 2 + x + y
>= 1 + x + y
= 0(+(x,y))
+(0(x),1(y)) = 2 + x + y
>= 1 + x + y
= 1(+(x,y))
+(1(x),0(y)) = 2 + x + y
>= 1 + x + y
= 1(+(x,y))
+(1(x),1(y)) = 2 + x + y
>= 2 + x + y
= 0(+(+(x,y),1(#())))
-(x,#()) = x
>= x
= x
-(#(),x) = 0
>= 0
= #()
-(0(x),0(y)) = 1 + x
>= 1 + x
= 0(-(x,y))
-(0(x),1(y)) = 1 + x
>= 1 + x
= 1(-(-(x,y),1(#())))
-(1(x),0(y)) = 1 + x
>= 1 + x
= 1(-(x,y))
-(1(x),1(y)) = 1 + x
>= 1 + x
= 0(-(x,y))
0(#()) = 1
>= 0
= #()
max(l(x)) = 1 + x
>= x
= x
max(n(x,y,z)) = 1 + x + y + z
>= z
= max(z)
min(l(x)) = 1 + x
>= x
= x
min(n(x,y,z)) = 1 + x + y + z
>= y
= min(y)
size(l(x)) = 1 + x
>= 1
= 1(#())
size(n(x,y,z)) = 1 + x + y + z
>= 1 + x + y
= +(+(size(x),size(y)),1(#()))
******** Step 1.b:7.b:3.b:3.a:3.b:3.b:3.a:2: Assumption WORST_CASE(?,O(1))
+ Considered Problem:
- Weak DPs:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),ge#(min(z),x),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/4,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/5}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
+ Details:
()
******** Step 1.b:7.b:3.b:3.a:3.b:3.b:3.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1))
+ Considered Problem:
- Weak DPs:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),ge#(min(z),x),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/4,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/5}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
RemoveWeakSuffixes
+ Details:
Consider the dependency graph
1:W:bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),ge#(min(z),x),bs#(y),bs#(z))
-->_2 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_2 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_2 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_2 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_2 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
-->_4 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),ge#(min(z),x),bs#(y),bs#(z)):1
-->_3 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),ge#(min(z),x),bs#(y),bs#(z)):1
2:W:ge#(#(),0(x)) -> c_20(ge#(#(),x))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
3:W:ge#(0(x),0(y)) -> c_22(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
4:W:ge#(0(x),1(y)) -> c_23(ge#(y,x))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
5:W:ge#(1(x),0(y)) -> c_24(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
6:W:ge#(1(x),1(y)) -> c_25(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
7:W:wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z))
-->_5 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z)):7
-->_4 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z)):7
-->_3 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_2 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):6
-->_3 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_2 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):5
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):4
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):3
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):2
The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
7: wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,ge#(1(#()),-(size(y),size(z)))
,ge#(1(#()),-(size(z),size(y)))
,wb#(y)
,wb#(z))
1: bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),ge#(min(z),x),bs#(y),bs#(z))
6: ge#(1(x),1(y)) -> c_25(ge#(x,y))
5: ge#(1(x),0(y)) -> c_24(ge#(x,y))
4: ge#(0(x),1(y)) -> c_23(ge#(y,x))
3: ge#(0(x),0(y)) -> c_22(ge#(x,y))
2: ge#(#(),0(x)) -> c_20(ge#(#(),x))
******** Step 1.b:7.b:3.b:3.a:3.b:3.b:3.b:2: EmptyProcessor WORST_CASE(?,O(1))
+ Considered Problem:
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/4,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/5}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
EmptyProcessor
+ Details:
The problem is already closed. The intended complexity is O(1).
***** Step 1.b:7.b:3.b:3.b:1: RemoveWeakSuffixes WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
size#(n(x,y,z)) -> c_35(size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
- Weak DPs:
bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
ge#(#(),0(x)) -> c_20(ge#(#(),x))
ge#(0(x),0(y)) -> c_22(ge#(x,y))
ge#(0(x),1(y)) -> c_23(ge#(y,x))
ge#(1(x),0(y)) -> c_24(ge#(x,y))
ge#(1(x),1(y)) -> c_25(ge#(x,y))
max#(n(x,y,z)) -> c_29(max#(z))
min#(n(x,y,z)) -> c_31(min#(y))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/11}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
RemoveWeakSuffixes
+ Details:
Consider the dependency graph
1:S:size#(n(x,y,z)) -> c_35(size#(x),size#(y))
-->_2 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):1
-->_1 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):1
2:S:wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
-->_7 ge#(1(x),1(y)) -> c_25(ge#(x,y)):8
-->_4 ge#(1(x),1(y)) -> c_25(ge#(x,y)):8
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):8
-->_7 ge#(1(x),0(y)) -> c_24(ge#(x,y)):7
-->_4 ge#(1(x),0(y)) -> c_24(ge#(x,y)):7
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):7
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):6
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):5
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):4
-->_11 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z)):2
-->_10 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z)):2
-->_9 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):1
-->_8 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):1
-->_6 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):1
-->_5 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):1
-->_3 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):1
-->_2 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):1
3:W:bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
-->_4 min#(n(x,y,z)) -> c_31(min#(y)):10
-->_2 max#(n(x,y,z)) -> c_29(max#(z)):9
-->_3 ge#(1(x),1(y)) -> c_25(ge#(x,y)):8
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):8
-->_3 ge#(1(x),0(y)) -> c_24(ge#(x,y)):7
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):7
-->_3 ge#(0(x),1(y)) -> c_23(ge#(y,x)):6
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):6
-->_3 ge#(0(x),0(y)) -> c_22(ge#(x,y)):5
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):5
-->_3 ge#(#(),0(x)) -> c_20(ge#(#(),x)):4
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):4
-->_6 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z)):3
-->_5 bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z)):3
4:W:ge#(#(),0(x)) -> c_20(ge#(#(),x))
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):4
5:W:ge#(0(x),0(y)) -> c_22(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):8
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):7
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):6
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):5
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):4
6:W:ge#(0(x),1(y)) -> c_23(ge#(y,x))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):8
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):7
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):6
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):5
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):4
7:W:ge#(1(x),0(y)) -> c_24(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):8
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):7
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):6
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):5
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):4
8:W:ge#(1(x),1(y)) -> c_25(ge#(x,y))
-->_1 ge#(1(x),1(y)) -> c_25(ge#(x,y)):8
-->_1 ge#(1(x),0(y)) -> c_24(ge#(x,y)):7
-->_1 ge#(0(x),1(y)) -> c_23(ge#(y,x)):6
-->_1 ge#(0(x),0(y)) -> c_22(ge#(x,y)):5
-->_1 ge#(#(),0(x)) -> c_20(ge#(#(),x)):4
9:W:max#(n(x,y,z)) -> c_29(max#(z))
-->_1 max#(n(x,y,z)) -> c_29(max#(z)):9
10:W:min#(n(x,y,z)) -> c_31(min#(y))
-->_1 min#(n(x,y,z)) -> c_31(min#(y)):10
The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
3: bs#(n(x,y,z)) -> c_18(ge#(x,max(y)),max#(y),ge#(min(z),x),min#(z),bs#(y),bs#(z))
9: max#(n(x,y,z)) -> c_29(max#(z))
10: min#(n(x,y,z)) -> c_31(min#(y))
8: ge#(1(x),1(y)) -> c_25(ge#(x,y))
7: ge#(1(x),0(y)) -> c_24(ge#(x,y))
6: ge#(0(x),1(y)) -> c_23(ge#(y,x))
5: ge#(0(x),0(y)) -> c_22(ge#(x,y))
4: ge#(#(),0(x)) -> c_20(ge#(#(),x))
***** Step 1.b:7.b:3.b:3.b:2: SimplifyRHS WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
size#(n(x,y,z)) -> c_35(size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/11}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
SimplifyRHS
+ Details:
Consider the dependency graph
1:S:size#(n(x,y,z)) -> c_35(size#(x),size#(y))
-->_2 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):1
-->_1 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):1
2:S:wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z))
-->_11 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z)):2
-->_10 wb#(n(x,y,z)) -> c_39(ge#(size(y),size(z))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(y),size(z)))
,size#(y)
,size#(z)
,ge#(1(#()),-(size(z),size(y)))
,size#(z)
,size#(y)
,wb#(y)
,wb#(z)):2
-->_9 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):1
-->_8 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):1
-->_6 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):1
-->_5 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):1
-->_3 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):1
-->_2 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):1
Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified:
wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
***** Step 1.b:7.b:3.b:3.b:3: UsableRules WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
size#(n(x,y,z)) -> c_35(size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
- Weak TRS:
+(x,#()) -> x
+(x,+(y,z)) -> +(+(x,y),z)
+(#(),x) -> x
+(0(x),0(y)) -> 0(+(x,y))
+(0(x),1(y)) -> 1(+(x,y))
+(1(x),0(y)) -> 1(+(x,y))
+(1(x),1(y)) -> 0(+(+(x,y),1(#())))
-(x,#()) -> x
-(#(),x) -> #()
-(0(x),0(y)) -> 0(-(x,y))
-(0(x),1(y)) -> 1(-(-(x,y),1(#())))
-(1(x),0(y)) -> 1(-(x,y))
-(1(x),1(y)) -> 0(-(x,y))
0(#()) -> #()
max(l(x)) -> x
max(n(x,y,z)) -> max(z)
min(l(x)) -> x
min(n(x,y,z)) -> min(y)
size(l(x)) -> 1(#())
size(n(x,y,z)) -> +(+(size(x),size(y)),1(#()))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
UsableRules
+ Details:
We replace rewrite rules by usable rules:
size#(n(x,y,z)) -> c_35(size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
***** Step 1.b:7.b:3.b:3.b:4: Decompose WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
size#(n(x,y,z)) -> c_35(size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ 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:
size#(n(x,y,z)) -> c_35(size#(x),size#(y))
- Weak DPs:
wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0
,c_4/1,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0
,c_20/1,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0
,c_35/2,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
Problem (S)
- Strict DPs:
wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
- Weak DPs:
size#(n(x,y,z)) -> c_35(size#(x),size#(y))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0
,c_4/1,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0
,c_20/1,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0
,c_35/2,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
****** Step 1.b:7.b:3.b:3.b:4.a:1: PredecessorEstimationCP WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
size#(n(x,y,z)) -> c_35(size#(x),size#(y))
- Weak DPs:
wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
PredecessorEstimationCP {onSelectionCP = any intersect of rules of CDG leaf and strict-rules, withComplexityPair = NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing}}
+ Details:
We first use the processor NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Nothing} to orient following rules strictly:
1: size#(n(x,y,z)) -> c_35(size#(x),size#(y))
The strictly oriented rules are moved into the weak component.
******* Step 1.b:7.b:3.b:3.b:4.a:1.a:1: NaturalPI WORST_CASE(?,O(n^2))
+ Considered Problem:
- Strict DPs:
size#(n(x,y,z)) -> c_35(size#(x),size#(y))
- Weak DPs:
wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
NaturalPI {shape = Mixed 2, restrict = Restrict, 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 polynomial interpretation of kind constructor-based(mixed(2)):
The following argument positions are considered usable:
uargs(c_35) = {1,2},
uargs(c_39) = {1,2,3,4,5,6,7,8}
Following symbols are considered usable:
{+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#,wb#}
TcT has computed the following interpretation:
p(#) = 0
p(+) = 1 + x1^2 + x2
p(-) = 1 + 4*x1*x2
p(0) = 1 + 2*x1 + x1^2
p(1) = 1
p(and) = 0
p(bs) = 2 + 4*x1
p(false) = 0
p(ge) = 2*x1^2 + 2*x2^2
p(if) = 1 + x2^2 + x3 + x3^2
p(l) = x1
p(max) = 1
p(min) = 4
p(n) = 1 + x1 + x2 + x3
p(not) = x1^2
p(size) = 2 + x1
p(true) = 0
p(val) = 1
p(wb) = 4 + 2*x1 + x1^2
p(+#) = 1 + x1 + x2
p(-#) = x1 + x1^2 + x2 + 2*x2^2
p(0#) = 2 + 4*x1 + x1^2
p(and#) = 1 + x1*x2 + 2*x1^2 + x2
p(bs#) = 2*x1 + 4*x1^2
p(ge#) = 4 + 2*x1^2 + 2*x2
p(if#) = x1 + 2*x1*x2 + x2 + 2*x2^2 + 4*x3 + 2*x3^2
p(max#) = 0
p(min#) = 2 + x1
p(not#) = 1
p(size#) = x1
p(val#) = x1^2
p(wb#) = 1 + x1 + 4*x1^2
p(c_1) = 1
p(c_2) = x1
p(c_3) = 0
p(c_4) = 0
p(c_5) = 1
p(c_6) = 1
p(c_7) = 0
p(c_8) = 1
p(c_9) = 0
p(c_10) = 1
p(c_11) = 0
p(c_12) = 0
p(c_13) = 1
p(c_14) = 0
p(c_15) = 0
p(c_16) = 0
p(c_17) = 0
p(c_18) = 1 + x6
p(c_19) = 1
p(c_20) = 1 + x1
p(c_21) = 1
p(c_22) = x1
p(c_23) = 0
p(c_24) = 1
p(c_25) = 1
p(c_26) = 0
p(c_27) = 0
p(c_28) = 1
p(c_29) = 0
p(c_30) = 1
p(c_31) = 1
p(c_32) = 0
p(c_33) = 1
p(c_34) = 0
p(c_35) = x1 + x2
p(c_36) = 0
p(c_37) = 0
p(c_38) = 1
p(c_39) = 1 + x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8
Following rules are strictly oriented:
size#(n(x,y,z)) = 1 + x + y + z
> x + y
= c_35(size#(x),size#(y))
Following rules are (at-least) weakly oriented:
wb#(n(x,y,z)) = 6 + 9*x + 8*x*y + 8*x*z + 4*x^2 + 9*y + 8*y*z + 4*y^2 + 9*z + 4*z^2
>= 3 + 4*y + 4*y^2 + 4*z + 4*z^2
= c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
******* Step 1.b:7.b:3.b:3.b:4.a:1.a:2: Assumption WORST_CASE(?,O(1))
+ Considered Problem:
- Weak DPs:
size#(n(x,y,z)) -> c_35(size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
+ Details:
()
******* Step 1.b:7.b:3.b:3.b:4.a:1.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1))
+ Considered Problem:
- Weak DPs:
size#(n(x,y,z)) -> c_35(size#(x),size#(y))
wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
RemoveWeakSuffixes
+ Details:
Consider the dependency graph
1:W:size#(n(x,y,z)) -> c_35(size#(x),size#(y))
-->_2 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):1
-->_1 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):1
2:W:wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
-->_8 wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z)):2
-->_7 wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z)):2
-->_6 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):1
-->_5 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):1
-->_4 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):1
-->_3 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):1
-->_2 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):1
-->_1 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):1
The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
2: wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
1: size#(n(x,y,z)) -> c_35(size#(x),size#(y))
******* Step 1.b:7.b:3.b:3.b:4.a:1.b:2: EmptyProcessor WORST_CASE(?,O(1))
+ Considered Problem:
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
EmptyProcessor
+ Details:
The problem is already closed. The intended complexity is O(1).
****** Step 1.b:7.b:3.b:3.b:4.b:1: RemoveWeakSuffixes WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
- Weak DPs:
size#(n(x,y,z)) -> c_35(size#(x),size#(y))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
RemoveWeakSuffixes
+ Details:
Consider the dependency graph
1:S:wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
-->_6 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):2
-->_5 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):2
-->_4 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):2
-->_3 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):2
-->_2 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):2
-->_1 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):2
-->_8 wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z)):1
-->_7 wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z)):1
2:W:size#(n(x,y,z)) -> c_35(size#(x),size#(y))
-->_2 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):2
-->_1 size#(n(x,y,z)) -> c_35(size#(x),size#(y)):2
The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
2: size#(n(x,y,z)) -> c_35(size#(x),size#(y))
****** Step 1.b:7.b:3.b:3.b:4.b:2: SimplifyRHS WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/8}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
SimplifyRHS
+ Details:
Consider the dependency graph
1:S:wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z))
-->_8 wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z)):1
-->_7 wb#(n(x,y,z)) -> c_39(size#(y),size#(z),size#(y),size#(z),size#(z),size#(y),wb#(y),wb#(z)):1
Due to missing edges in the depndency graph, the right-hand sides of following rules could be simplified:
wb#(n(x,y,z)) -> c_39(wb#(y),wb#(z))
****** Step 1.b:7.b:3.b:3.b:4.b:3: PredecessorEstimationCP WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
wb#(n(x,y,z)) -> c_39(wb#(y),wb#(z))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/2}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ 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: wb#(n(x,y,z)) -> c_39(wb#(y),wb#(z))
The strictly oriented rules are moved into the weak component.
******* Step 1.b:7.b:3.b:3.b:4.b:3.a:1: NaturalMI WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict DPs:
wb#(n(x,y,z)) -> c_39(wb#(y),wb#(z))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/2}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ 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_39) = {1,2}
Following symbols are considered usable:
{+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#,wb#}
TcT has computed the following interpretation:
p(#) = [1]
p(+) = [4]
p(-) = [0]
p(0) = [0]
p(1) = [1] x1 + [0]
p(and) = [1]
p(bs) = [0]
p(false) = [0]
p(ge) = [1] x1 + [1] x2 + [0]
p(if) = [1] x2 + [2] x3 + [1]
p(l) = [1]
p(max) = [1]
p(min) = [0]
p(n) = [1] x1 + [1] x2 + [1] x3 + [1]
p(not) = [0]
p(size) = [0]
p(true) = [0]
p(val) = [0]
p(wb) = [0]
p(+#) = [0]
p(-#) = [0]
p(0#) = [0]
p(and#) = [0]
p(bs#) = [0]
p(ge#) = [0]
p(if#) = [0]
p(max#) = [0]
p(min#) = [0]
p(not#) = [0]
p(size#) = [0]
p(val#) = [0]
p(wb#) = [9] x1 + [7]
p(c_1) = [0]
p(c_2) = [2] x1 + [1] x2 + [0]
p(c_3) = [0]
p(c_4) = [1] x1 + [0]
p(c_5) = [8] x1 + [0]
p(c_6) = [1] x1 + [0]
p(c_7) = [1] x2 + [0]
p(c_8) = [0]
p(c_9) = [0]
p(c_10) = [1] x1 + [0]
p(c_11) = [8] x2 + [0]
p(c_12) = [1] x1 + [0]
p(c_13) = [1] x1 + [0]
p(c_14) = [0]
p(c_15) = [0]
p(c_16) = [0]
p(c_17) = [0]
p(c_18) = [1] x1 + [2] x2 + [1] x3 + [1] x4 + [8] x5 + [0]
p(c_19) = [0]
p(c_20) = [0]
p(c_21) = [0]
p(c_22) = [1] x1 + [0]
p(c_23) = [0]
p(c_24) = [1] x1 + [0]
p(c_25) = [1] x1 + [0]
p(c_26) = [0]
p(c_27) = [0]
p(c_28) = [0]
p(c_29) = [0]
p(c_30) = [0]
p(c_31) = [2] x1 + [0]
p(c_32) = [2]
p(c_33) = [4]
p(c_34) = [0]
p(c_35) = [1]
p(c_36) = [2]
p(c_37) = [1]
p(c_38) = [8]
p(c_39) = [1] x1 + [1] x2 + [1]
Following rules are strictly oriented:
wb#(n(x,y,z)) = [9] x + [9] y + [9] z + [16]
> [9] y + [9] z + [15]
= c_39(wb#(y),wb#(z))
Following rules are (at-least) weakly oriented:
******* Step 1.b:7.b:3.b:3.b:4.b:3.a:2: Assumption WORST_CASE(?,O(1))
+ Considered Problem:
- Weak DPs:
wb#(n(x,y,z)) -> c_39(wb#(y),wb#(z))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/2}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown}}
+ Details:
()
******* Step 1.b:7.b:3.b:3.b:4.b:3.b:1: RemoveWeakSuffixes WORST_CASE(?,O(1))
+ Considered Problem:
- Weak DPs:
wb#(n(x,y,z)) -> c_39(wb#(y),wb#(z))
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/2}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
RemoveWeakSuffixes
+ Details:
Consider the dependency graph
1:W:wb#(n(x,y,z)) -> c_39(wb#(y),wb#(z))
-->_2 wb#(n(x,y,z)) -> c_39(wb#(y),wb#(z)):1
-->_1 wb#(n(x,y,z)) -> c_39(wb#(y),wb#(z)):1
The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed.
1: wb#(n(x,y,z)) -> c_39(wb#(y),wb#(z))
******* Step 1.b:7.b:3.b:3.b:4.b:3.b:2: EmptyProcessor WORST_CASE(?,O(1))
+ Considered Problem:
- Signature:
{+/2,-/2,0/1,and/2,bs/1,ge/2,if/3,max/1,min/1,not/1,size/1,val/1,wb/1,+#/2,-#/2,0#/1,and#/2,bs#/1,ge#/2
,if#/3,max#/1,min#/1,not#/1,size#/1,val#/1,wb#/1} / {#/0,1/1,false/0,l/1,n/3,true/0,c_1/0,c_2/2,c_3/0,c_4/1
,c_5/1,c_6/1,c_7/2,c_8/0,c_9/0,c_10/1,c_11/2,c_12/1,c_13/1,c_14/0,c_15/0,c_16/0,c_17/0,c_18/6,c_19/0,c_20/1
,c_21/0,c_22/1,c_23/1,c_24/1,c_25/1,c_26/0,c_27/0,c_28/0,c_29/1,c_30/0,c_31/1,c_32/0,c_33/0,c_34/0,c_35/2
,c_36/0,c_37/0,c_38/0,c_39/2}
- Obligation:
innermost runtime complexity wrt. defined symbols {+#,-#,0#,and#,bs#,ge#,if#,max#,min#,not#,size#,val#
,wb#} and constructors {#,1,false,l,n,true}
+ Applied Processor:
EmptyProcessor
+ Details:
The problem is already closed. The intended complexity is O(1).
WORST_CASE(Omega(n^1),O(n^4))