WORST_CASE(?,O(n^1)) * 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: innermost 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(.) = [1] x2 + [0] p(=) = [7] p(and) = [1] x1 + [1] x2 + [11] p(del) = [0] p(f) = [1] x1 + [1] p(false) = [0] p(nil) = [0] p(true) = [0] p(u) = [0] p(v) = [0] Following rules are strictly oriented: =(.(x,y),nil()) = [7] > [0] = false() =(nil(),.(y,z)) = [7] > [0] = false() =(nil(),nil()) = [7] > [0] = true() f(false(),x,y,z) = [1] > [0] = .(x,del(.(y,z))) f(true(),x,y,z) = [1] > [0] = del(.(y,z)) Following rules are (at-least) weakly oriented: =(.(x,y),.(u(),v())) = [7] >= [25] = and(=(x,u()),=(y,v())) del(.(x,.(y,z))) = [0] >= [8] = 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())) del(.(x,.(y,z))) -> f(=(x,y),x,y,z) - Weak TRS: =(.(x,y),nil()) -> false() =(nil(),.(y,z)) -> false() =(nil(),nil()) -> true() 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: innermost 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(.) = [1] x2 + [0] p(=) = [1] p(and) = [0] p(del) = [0] p(f) = [1] x1 + [0] p(false) = [0] p(nil) = [0] p(true) = [0] p(u) = [8] p(v) = [1] Following rules are strictly oriented: =(.(x,y),.(u(),v())) = [1] > [0] = and(=(x,u()),=(y,v())) Following rules are (at-least) weakly oriented: =(.(x,y),nil()) = [1] >= [0] = false() =(nil(),.(y,z)) = [1] >= [0] = false() =(nil(),nil()) = [1] >= [0] = true() del(.(x,.(y,z))) = [0] >= [1] = f(=(x,y),x,y,z) f(false(),x,y,z) = [0] >= [0] = .(x,del(.(y,z))) f(true(),x,y,z) = [0] >= [0] = 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: del(.(x,.(y,z))) -> f(=(x,y),x,y,z) - Weak TRS: =(.(x,y),.(u(),v())) -> and(=(x,u()),=(y,v())) =(.(x,y),nil()) -> false() =(nil(),.(y,z)) -> false() =(nil(),nil()) -> true() 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: innermost 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(.) = [1] x2 + [4] p(=) = [1] p(and) = [1] x1 + [0] p(del) = [2] x1 + [2] p(f) = [1] x1 + [2] x4 + [13] p(false) = [1] p(nil) = [0] p(true) = [1] p(u) = [1] p(v) = [0] Following rules are strictly oriented: del(.(x,.(y,z))) = [2] z + [18] > [2] z + [14] = f(=(x,y),x,y,z) Following rules are (at-least) weakly oriented: =(.(x,y),.(u(),v())) = [1] >= [1] = and(=(x,u()),=(y,v())) =(.(x,y),nil()) = [1] >= [1] = false() =(nil(),.(y,z)) = [1] >= [1] = false() =(nil(),nil()) = [1] >= [1] = true() f(false(),x,y,z) = [2] z + [14] >= [2] z + [14] = .(x,del(.(y,z))) f(true(),x,y,z) = [2] z + [14] >= [2] z + [10] = 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: innermost 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))