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: NaturalMI 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: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just any strict-rules} + Details: 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: {=,del,f} TcT has computed the following interpretation: p(.) = [1] x2 + [0] p(=) = [2] p(and) = [0] p(del) = [4] p(f) = [2] x1 + [0] p(false) = [2] p(nil) = [0] p(true) = [2] p(u) = [0] p(v) = [0] Following rules are strictly oriented: =(.(x,y),.(u(),v())) = [2] > [0] = and(=(x,u()),=(y,v())) Following rules are (at-least) weakly oriented: =(.(x,y),nil()) = [2] >= [2] = false() =(nil(),.(y,z)) = [2] >= [2] = false() =(nil(),nil()) = [2] >= [2] = true() del(.(x,.(y,z))) = [4] >= [4] = f(=(x,y),x,y,z) f(false(),x,y,z) = [4] >= [4] = .(x,del(.(y,z))) f(true(),x,y,z) = [4] >= [4] = del(.(y,z)) * Step 3: NaturalMI 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: NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Just any strict-rules} + Details: 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: {=,del,f} TcT has computed the following interpretation: p(.) = [1] x2 + [1] p(=) = [1] p(and) = [1] p(del) = [8] x1 + [1] p(f) = [8] x1 + [8] x4 + [2] p(false) = [1] p(nil) = [0] p(true) = [1] p(u) = [0] p(v) = [1] Following rules are strictly oriented: del(.(x,.(y,z))) = [8] z + [17] > [8] z + [10] = 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) = [8] z + [10] >= [8] z + [10] = .(x,del(.(y,z))) f(true(),x,y,z) = [8] z + [10] >= [8] z + [9] = del(.(y,z)) * 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))