```* Step 1: WeightGap WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict TRS:
=(.(x,y),.(u(),v())) -> and(=(x,u()),=(y,v()))
=(.(x,y),nil()) -> false()
=(nil(),.(y,z)) -> false()
=(nil(),nil()) -> true()
del(.(x,.(y,z))) -> f(=(x,y),x,y,z)
f(false(),x,y,z) -> .(x,del(.(y,z)))
f(true(),x,y,z) -> del(.(y,z))
- Signature:
{=/2,del/1,f/4} / {./2,and/2,false/0,nil/0,true/0,u/0,v/0}
- Obligation:
runtime complexity wrt. defined symbols {=,del,f} and constructors {.,and,false,nil,true,u,v}
+ Applied Processor:
WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
+ Details:
The weightgap principle applies using the following nonconstant growth matrix-interpretation:
We apply a matrix interpretation of kind constructor based matrix interpretation:
The following argument positions are considered usable:
uargs(.) = {2},
uargs(f) = {1}

Following symbols are considered usable:
all
TcT has computed the following interpretation:
p(.) =  x2 + 
p(=) = 
p(and) =  x1 +  x2 + 
p(del) = 
p(f) =  x1 + 
p(false) = 
p(nil) = 
p(true) = 
p(u) = 
p(v) = 

Following rules are strictly oriented:
f(false(),x,y,z) = 
> 
= .(x,del(.(y,z)))

f(true(),x,y,z) = 
> 
= del(.(y,z))

Following rules are (at-least) weakly oriented:
=(.(x,y),.(u(),v())) =  
>= 
=  and(=(x,u()),=(y,v()))

=(.(x,y),nil()) =  
>= 
=  false()

=(nil(),.(y,z)) =  
>= 
=  false()

=(nil(),nil()) =  
>= 
=  true()

del(.(x,.(y,z))) =  
>= 
=  f(=(x,y),x,y,z)

Further, it can be verified that all rules not oriented are covered by the weightgap condition.
* Step 2: WeightGap WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict TRS:
=(.(x,y),.(u(),v())) -> and(=(x,u()),=(y,v()))
=(.(x,y),nil()) -> false()
=(nil(),.(y,z)) -> false()
=(nil(),nil()) -> true()
del(.(x,.(y,z))) -> f(=(x,y),x,y,z)
- Weak TRS:
f(false(),x,y,z) -> .(x,del(.(y,z)))
f(true(),x,y,z) -> del(.(y,z))
- Signature:
{=/2,del/1,f/4} / {./2,and/2,false/0,nil/0,true/0,u/0,v/0}
- Obligation:
runtime complexity wrt. defined symbols {=,del,f} and constructors {.,and,false,nil,true,u,v}
+ Applied Processor:
WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
+ Details:
The weightgap principle applies using the following nonconstant growth matrix-interpretation:
We apply a matrix interpretation of kind constructor based matrix interpretation:
The following argument positions are considered usable:
uargs(.) = {2},
uargs(f) = {1}

Following symbols are considered usable:
all
TcT has computed the following interpretation:
p(.) =  x1 +  x2 + 
p(=) =  x1 + 
p(and) = 
p(del) =  x1 + 
p(f) =  x1 +  x2 +  x3 +  x4 + 
p(false) = 
p(nil) = 
p(true) = 
p(u) = 
p(v) = 

Following rules are strictly oriented:
=(.(x,y),.(u(),v())) =  x +  y + 
> 
= and(=(x,u()),=(y,v()))

=(nil(),.(y,z)) = 
> 
= false()

=(nil(),nil()) = 
> 
= true()

del(.(x,.(y,z))) =  x +  y +  z + 
>  x +  y +  z + 
= f(=(x,y),x,y,z)

Following rules are (at-least) weakly oriented:
=(.(x,y),nil()) =   x +  y + 
>= 
=  false()

f(false(),x,y,z) =   x +  y +  z + 
>=  x +  y +  z + 
=  .(x,del(.(y,z)))

f(true(),x,y,z) =   x +  y +  z + 
>=  y +  z + 
=  del(.(y,z))

Further, it can be verified that all rules not oriented are covered by the weightgap condition.
* Step 3: WeightGap WORST_CASE(?,O(n^1))
+ Considered Problem:
- Strict TRS:
=(.(x,y),nil()) -> false()
- Weak TRS:
=(.(x,y),.(u(),v())) -> and(=(x,u()),=(y,v()))
=(nil(),.(y,z)) -> false()
=(nil(),nil()) -> true()
del(.(x,.(y,z))) -> f(=(x,y),x,y,z)
f(false(),x,y,z) -> .(x,del(.(y,z)))
f(true(),x,y,z) -> del(.(y,z))
- Signature:
{=/2,del/1,f/4} / {./2,and/2,false/0,nil/0,true/0,u/0,v/0}
- Obligation:
runtime complexity wrt. defined symbols {=,del,f} and constructors {.,and,false,nil,true,u,v}
+ Applied Processor:
WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
+ Details:
The weightgap principle applies using the following nonconstant growth matrix-interpretation:
We apply a matrix interpretation of kind constructor based matrix interpretation:
The following argument positions are considered usable:
uargs(.) = {2},
uargs(f) = {1}

Following symbols are considered usable:
all
TcT has computed the following interpretation:
p(.) =  x1 +  x2 + 
p(=) =  x1 + 
p(and) =  x1 +  x2 + 
p(del) =  x1 + 
p(f) =  x1 +  x2 +  x3 +  x4 + 
p(false) = 
p(nil) = 
p(true) = 
p(u) = 
p(v) = 

Following rules are strictly oriented:
=(.(x,y),nil()) =  x +  y + 
> 
= false()

Following rules are (at-least) weakly oriented:
=(.(x,y),.(u(),v())) =   x +  y + 
>=  x +  y + 
=  and(=(x,u()),=(y,v()))

=(nil(),.(y,z)) =  
>= 
=  false()

=(nil(),nil()) =  
>= 
=  true()

del(.(x,.(y,z))) =   x +  y +  z + 
>=  x +  y +  z + 
=  f(=(x,y),x,y,z)

f(false(),x,y,z) =   x +  y +  z + 
>=  x +  y +  z + 
=  .(x,del(.(y,z)))

f(true(),x,y,z) =   x +  y +  z + 
>=  y +  z + 
=  del(.(y,z))

Further, it can be verified that all rules not oriented are covered by the weightgap condition.
* Step 4: EmptyProcessor WORST_CASE(?,O(1))
+ Considered Problem:
- Weak TRS:
=(.(x,y),.(u(),v())) -> and(=(x,u()),=(y,v()))
=(.(x,y),nil()) -> false()
=(nil(),.(y,z)) -> false()
=(nil(),nil()) -> true()
del(.(x,.(y,z))) -> f(=(x,y),x,y,z)
f(false(),x,y,z) -> .(x,del(.(y,z)))
f(true(),x,y,z) -> del(.(y,z))
- Signature:
{=/2,del/1,f/4} / {./2,and/2,false/0,nil/0,true/0,u/0,v/0}
- Obligation:
runtime complexity wrt. defined symbols {=,del,f} and constructors {.,and,false,nil,true,u,v}
+ Applied Processor:
EmptyProcessor
+ Details:
The problem is already closed. The intended complexity is O(1).

WORST_CASE(?,O(n^1))
```