/export/starexec/sandbox2/solver/bin/starexec_run_tct_rc /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/output/output_files -------------------------------------------------------------------------------- WORST_CASE(Omega(n^1),O(n^1)) * Step 1: Sum. WORST_CASE(Omega(n^1),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: Sum {left = someStrategy, right = someStrategy} + Details: () ** Step 1.a:1: Sum. WORST_CASE(Omega(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: Sum {left = someStrategy, right = someStrategy} + Details: () ** Step 1.a:2: DecreasingLoops. WORST_CASE(Omega(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: DecreasingLoops {bound = AnyLoop, narrow = 10} + Details: The system has following decreasing Loops: del(.(nil(),v)){v -> .(nil(),v)} = del(.(nil(),.(nil(),v))) ->^+ del(.(nil(),v)) = C[del(.(nil(),v)) = del(.(nil(),v)){}] ** Step 1.b:1: NaturalMI. 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: 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: all TcT has computed the following interpretation: p(.) = [1] x2 + [1] p(=) = [12] p(and) = [1] x2 + [0] p(del) = [8] x1 + [14] p(f) = [2] x1 + [8] x4 + [1] p(false) = [12] p(nil) = [1] p(true) = [12] p(u) = [1] p(v) = [0] Following rules are strictly oriented: del(.(x,.(y,z))) = [8] z + [30] > [8] z + [25] = f(=(x,y),x,y,z) f(false(),x,y,z) = [8] z + [25] > [8] z + [23] = .(x,del(.(y,z))) f(true(),x,y,z) = [8] z + [25] > [8] z + [22] = del(.(y,z)) Following rules are (at-least) weakly oriented: =(.(x,y),.(u(),v())) = [12] >= [12] = and(=(x,u()),=(y,v())) =(.(x,y),nil()) = [12] >= [12] = false() =(nil(),.(y,z)) = [12] >= [12] = false() =(nil(),nil()) = [12] >= [12] = true() ** Step 1.b:2: NaturalMI. 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() - Weak TRS: 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: 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: all TcT has computed the following interpretation: p(.) = [1] x1 + [1] x2 + [1] p(=) = [4] x1 + [10] p(and) = [1] x2 + [4] p(del) = [9] x1 + [2] p(f) = [2] x1 + [1] x2 + [9] x3 + [9] x4 + [0] p(false) = [11] p(nil) = [5] p(true) = [8] p(u) = [2] p(v) = [0] Following rules are strictly oriented: =(.(x,y),nil()) = [4] x + [4] y + [14] > [11] = false() =(nil(),.(y,z)) = [30] > [11] = false() =(nil(),nil()) = [30] > [8] = true() Following rules are (at-least) weakly oriented: =(.(x,y),.(u(),v())) = [4] x + [4] y + [14] >= [4] y + [14] = and(=(x,u()),=(y,v())) del(.(x,.(y,z))) = [9] x + [9] y + [9] z + [20] >= [9] x + [9] y + [9] z + [20] = f(=(x,y),x,y,z) f(false(),x,y,z) = [1] x + [9] y + [9] z + [22] >= [1] x + [9] y + [9] z + [12] = .(x,del(.(y,z))) f(true(),x,y,z) = [1] x + [9] y + [9] z + [16] >= [9] y + [9] z + [11] = del(.(y,z)) ** Step 1.b:3: NaturalMI. WORST_CASE(?,O(n^1)) + Considered Problem: - Strict TRS: =(.(x,y),.(u(),v())) -> and(=(x,u()),=(y,v())) - Weak TRS: =(.(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: 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: all TcT has computed the following interpretation: p(.) = [1] x1 + [1] x2 + [0] p(=) = [2] x1 + [2] p(and) = [0] p(del) = [13] x1 + [8] p(f) = [4] x1 + [4] x2 + [13] x3 + [13] x4 + [0] p(false) = [2] p(nil) = [8] p(true) = [2] p(u) = [0] p(v) = [8] Following rules are strictly oriented: =(.(x,y),.(u(),v())) = [2] x + [2] y + [2] > [0] = and(=(x,u()),=(y,v())) Following rules are (at-least) weakly oriented: =(.(x,y),nil()) = [2] x + [2] y + [2] >= [2] = false() =(nil(),.(y,z)) = [18] >= [2] = false() =(nil(),nil()) = [18] >= [2] = true() del(.(x,.(y,z))) = [13] x + [13] y + [13] z + [8] >= [12] x + [13] y + [13] z + [8] = f(=(x,y),x,y,z) f(false(),x,y,z) = [4] x + [13] y + [13] z + [8] >= [1] x + [13] y + [13] z + [8] = .(x,del(.(y,z))) f(true(),x,y,z) = [4] x + [13] y + [13] z + [8] >= [13] y + [13] z + [8] = del(.(y,z)) ** Step 1.b: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(Omega(n^1),O(n^1))