/export/starexec/sandbox/solver/bin/starexec_run_tct_rci /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files -------------------------------------------------------------------------------- WORST_CASE(?,O(n^1)) * Step 1: Sum. WORST_CASE(?,O(n^1)) + Considered Problem: - Strict TRS: group3(@l) -> group3#1(@l) group3#1(::(@x,@xs)) -> group3#2(@xs,@x) group3#1(nil()) -> nil() group3#2(::(@y,@ys),@x) -> group3#3(@ys,@x,@y) group3#2(nil(),@x) -> nil() group3#3(::(@z,@zs),@x,@y) -> ::(tuple#3(@x,@y,@z),group3(@zs)) group3#3(nil(),@x,@y) -> nil() zip3(@l1,@l2,@l3) -> zip3#1(@l1,@l2,@l3) zip3#1(::(@x,@xs),@l2,@l3) -> zip3#2(@l2,@l3,@x,@xs) zip3#1(nil(),@l2,@l3) -> nil() zip3#2(::(@y,@ys),@l3,@x,@xs) -> zip3#3(@l3,@x,@xs,@y,@ys) zip3#2(nil(),@l3,@x,@xs) -> nil() zip3#3(::(@z,@zs),@x,@xs,@y,@ys) -> ::(tuple#3(@x,@y,@z),zip3(@xs,@ys,@zs)) zip3#3(nil(),@x,@xs,@y,@ys) -> nil() - Signature: {group3/1,group3#1/1,group3#2/2,group3#3/3,zip3/3,zip3#1/3,zip3#2/4,zip3#3/5} / {::/2,nil/0,tuple#3/3} - Obligation: innermost runtime complexity wrt. defined symbols {group3,group3#1,group3#2,group3#3,zip3,zip3#1,zip3#2 ,zip3#3} and constructors {::,nil,tuple#3} + Applied Processor: Sum {left = someStrategy, right = someStrategy} + Details: () * Step 2: Ara. WORST_CASE(?,O(n^1)) + Considered Problem: - Strict TRS: group3(@l) -> group3#1(@l) group3#1(::(@x,@xs)) -> group3#2(@xs,@x) group3#1(nil()) -> nil() group3#2(::(@y,@ys),@x) -> group3#3(@ys,@x,@y) group3#2(nil(),@x) -> nil() group3#3(::(@z,@zs),@x,@y) -> ::(tuple#3(@x,@y,@z),group3(@zs)) group3#3(nil(),@x,@y) -> nil() zip3(@l1,@l2,@l3) -> zip3#1(@l1,@l2,@l3) zip3#1(::(@x,@xs),@l2,@l3) -> zip3#2(@l2,@l3,@x,@xs) zip3#1(nil(),@l2,@l3) -> nil() zip3#2(::(@y,@ys),@l3,@x,@xs) -> zip3#3(@l3,@x,@xs,@y,@ys) zip3#2(nil(),@l3,@x,@xs) -> nil() zip3#3(::(@z,@zs),@x,@xs,@y,@ys) -> ::(tuple#3(@x,@y,@z),zip3(@xs,@ys,@zs)) zip3#3(nil(),@x,@xs,@y,@ys) -> nil() - Signature: {group3/1,group3#1/1,group3#2/2,group3#3/3,zip3/3,zip3#1/3,zip3#2/4,zip3#3/5} / {::/2,nil/0,tuple#3/3} - Obligation: innermost runtime complexity wrt. defined symbols {group3,group3#1,group3#2,group3#3,zip3,zip3#1,zip3#2 ,zip3#3} and constructors {::,nil,tuple#3} + Applied Processor: Ara {minDegree = 1, maxDegree = 1, araTimeout = 8, araRuleShifting = Just 1, isBestCase = False, mkCompletelyDefined = False, verboseOutput = False} + Details: Signatures used: ---------------- F (TrsFun "::") :: ["A"(0) x "A"(0)] -(0)-> "A"(0) F (TrsFun "group3") :: ["A"(0)] -(1)-> "A"(0) F (TrsFun "group3#1") :: ["A"(0)] -(1)-> "A"(0) F (TrsFun "group3#2") :: ["A"(0) x "A"(0)] -(1)-> "A"(0) F (TrsFun "group3#3") :: ["A"(0) x "A"(0) x "A"(0)] -(1)-> "A"(0) F (TrsFun "nil") :: [] -(0)-> "A"(0) F (TrsFun "tuple#3") :: ["A"(0) x "A"(0) x "A"(0)] -(0)-> "A"(0) F (TrsFun "zip3") :: ["A"(0) x "A"(0) x "A"(0)] -(1)-> "A"(0) F (TrsFun "zip3#1") :: ["A"(0) x "A"(0) x "A"(0)] -(1)-> "A"(0) F (TrsFun "zip3#2") :: ["A"(0) x "A"(0) x "A"(0) x "A"(0)] -(1)-> "A"(0) F (TrsFun "zip3#3") :: ["A"(0) x "A"(0) x "A"(0) x "A"(0) x "A"(0)] -(1)-> "A"(0) Cost-free Signatures used: -------------------------- Base Constructor Signatures used: --------------------------------- Following Still Strict Rules were Typed as: ------------------------------------------- 1. Strict: group3#1(nil()) -> nil() group3#3(nil(),@x,@y) -> nil() zip3#1(nil(),@l2,@l3) -> nil() zip3#2(nil(),@l3,@x,@xs) -> nil() zip3#3(nil(),@x,@xs,@y,@ys) -> nil() 2. Weak: group3(@l) -> group3#1(@l) group3#1(::(@x,@xs)) -> group3#2(@xs,@x) group3#2(::(@y,@ys),@x) -> group3#3(@ys,@x,@y) group3#2(nil(),@x) -> nil() group3#3(::(@z,@zs),@x,@y) -> ::(tuple#3(@x,@y,@z),group3(@zs)) zip3(@l1,@l2,@l3) -> zip3#1(@l1,@l2,@l3) zip3#1(::(@x,@xs),@l2,@l3) -> zip3#2(@l2,@l3,@x,@xs) zip3#2(::(@y,@ys),@l3,@x,@xs) -> zip3#3(@l3,@x,@xs,@y,@ys) zip3#3(::(@z,@zs),@x,@xs,@y,@ys) -> ::(tuple#3(@x,@y,@z),zip3(@xs,@ys,@zs)) * Step 3: NaturalMI. WORST_CASE(?,O(n^1)) + Considered Problem: - Strict TRS: group3(@l) -> group3#1(@l) group3#1(::(@x,@xs)) -> group3#2(@xs,@x) group3#2(::(@y,@ys),@x) -> group3#3(@ys,@x,@y) group3#2(nil(),@x) -> nil() group3#3(::(@z,@zs),@x,@y) -> ::(tuple#3(@x,@y,@z),group3(@zs)) zip3(@l1,@l2,@l3) -> zip3#1(@l1,@l2,@l3) zip3#1(::(@x,@xs),@l2,@l3) -> zip3#2(@l2,@l3,@x,@xs) zip3#2(::(@y,@ys),@l3,@x,@xs) -> zip3#3(@l3,@x,@xs,@y,@ys) zip3#3(::(@z,@zs),@x,@xs,@y,@ys) -> ::(tuple#3(@x,@y,@z),zip3(@xs,@ys,@zs)) - Weak TRS: group3#1(nil()) -> nil() group3#3(nil(),@x,@y) -> nil() zip3#1(nil(),@l2,@l3) -> nil() zip3#2(nil(),@l3,@x,@xs) -> nil() zip3#3(nil(),@x,@xs,@y,@ys) -> nil() - Signature: {group3/1,group3#1/1,group3#2/2,group3#3/3,zip3/3,zip3#1/3,zip3#2/4,zip3#3/5} / {::/2,nil/0,tuple#3/3} - Obligation: innermost runtime complexity wrt. defined symbols {group3,group3#1,group3#2,group3#3,zip3,zip3#1,zip3#2 ,zip3#3} and constructors {::,nil,tuple#3} + 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} Following symbols are considered usable: {group3,group3#1,group3#2,group3#3,zip3,zip3#1,zip3#2,zip3#3} TcT has computed the following interpretation: p(::) = [1] x1 + [1] x2 + [10] p(group3) = [1] x1 + [4] p(group3#1) = [1] x1 + [2] p(group3#2) = [1] x1 + [1] x2 + [9] p(group3#3) = [1] x1 + [13] p(nil) = [1] p(tuple#3) = [1] x3 + [4] p(zip3) = [2] x3 + [7] p(zip3#1) = [2] x3 + [4] p(zip3#2) = [2] x2 + [3] p(zip3#3) = [2] x1 + [1] Following rules are strictly oriented: group3(@l) = [1] @l + [4] > [1] @l + [2] = group3#1(@l) group3#1(::(@x,@xs)) = [1] @x + [1] @xs + [12] > [1] @x + [1] @xs + [9] = group3#2(@xs,@x) group3#2(::(@y,@ys),@x) = [1] @x + [1] @y + [1] @ys + [19] > [1] @ys + [13] = group3#3(@ys,@x,@y) group3#2(nil(),@x) = [1] @x + [10] > [1] = nil() group3#3(::(@z,@zs),@x,@y) = [1] @z + [1] @zs + [23] > [1] @z + [1] @zs + [18] = ::(tuple#3(@x,@y,@z),group3(@zs)) zip3(@l1,@l2,@l3) = [2] @l3 + [7] > [2] @l3 + [4] = zip3#1(@l1,@l2,@l3) zip3#1(::(@x,@xs),@l2,@l3) = [2] @l3 + [4] > [2] @l3 + [3] = zip3#2(@l2,@l3,@x,@xs) zip3#2(::(@y,@ys),@l3,@x,@xs) = [2] @l3 + [3] > [2] @l3 + [1] = zip3#3(@l3,@x,@xs,@y,@ys) Following rules are (at-least) weakly oriented: group3#1(nil()) = [3] >= [1] = nil() group3#3(nil(),@x,@y) = [14] >= [1] = nil() zip3#1(nil(),@l2,@l3) = [2] @l3 + [4] >= [1] = nil() zip3#2(nil(),@l3,@x,@xs) = [2] @l3 + [3] >= [1] = nil() zip3#3(::(@z,@zs),@x,@xs,@y,@ys) = [2] @z + [2] @zs + [21] >= [1] @z + [2] @zs + [21] = ::(tuple#3(@x,@y,@z),zip3(@xs,@ys,@zs)) zip3#3(nil(),@x,@xs,@y,@ys) = [3] >= [1] = nil() * Step 4: NaturalMI. WORST_CASE(?,O(n^1)) + Considered Problem: - Strict TRS: zip3#3(::(@z,@zs),@x,@xs,@y,@ys) -> ::(tuple#3(@x,@y,@z),zip3(@xs,@ys,@zs)) - Weak TRS: group3(@l) -> group3#1(@l) group3#1(::(@x,@xs)) -> group3#2(@xs,@x) group3#1(nil()) -> nil() group3#2(::(@y,@ys),@x) -> group3#3(@ys,@x,@y) group3#2(nil(),@x) -> nil() group3#3(::(@z,@zs),@x,@y) -> ::(tuple#3(@x,@y,@z),group3(@zs)) group3#3(nil(),@x,@y) -> nil() zip3(@l1,@l2,@l3) -> zip3#1(@l1,@l2,@l3) zip3#1(::(@x,@xs),@l2,@l3) -> zip3#2(@l2,@l3,@x,@xs) zip3#1(nil(),@l2,@l3) -> nil() zip3#2(::(@y,@ys),@l3,@x,@xs) -> zip3#3(@l3,@x,@xs,@y,@ys) zip3#2(nil(),@l3,@x,@xs) -> nil() zip3#3(nil(),@x,@xs,@y,@ys) -> nil() - Signature: {group3/1,group3#1/1,group3#2/2,group3#3/3,zip3/3,zip3#1/3,zip3#2/4,zip3#3/5} / {::/2,nil/0,tuple#3/3} - Obligation: innermost runtime complexity wrt. defined symbols {group3,group3#1,group3#2,group3#3,zip3,zip3#1,zip3#2 ,zip3#3} and constructors {::,nil,tuple#3} + 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} Following symbols are considered usable: {group3,group3#1,group3#2,group3#3,zip3,zip3#1,zip3#2,zip3#3} TcT has computed the following interpretation: p(::) = [1] x2 + [8] p(group3) = [1] x1 + [5] p(group3#1) = [1] x1 + [1] p(group3#2) = [1] x1 + [2] p(group3#3) = [1] x1 + [10] p(nil) = [0] p(tuple#3) = [1] x2 + [1] x3 + [0] p(zip3) = [1] x1 + [1] x3 + [4] p(zip3#1) = [1] x1 + [1] x3 + [0] p(zip3#2) = [1] x2 + [1] x4 + [8] p(zip3#3) = [1] x1 + [1] x3 + [8] Following rules are strictly oriented: zip3#3(::(@z,@zs),@x,@xs,@y,@ys) = [1] @xs + [1] @zs + [16] > [1] @xs + [1] @zs + [12] = ::(tuple#3(@x,@y,@z),zip3(@xs,@ys,@zs)) Following rules are (at-least) weakly oriented: group3(@l) = [1] @l + [5] >= [1] @l + [1] = group3#1(@l) group3#1(::(@x,@xs)) = [1] @xs + [9] >= [1] @xs + [2] = group3#2(@xs,@x) group3#1(nil()) = [1] >= [0] = nil() group3#2(::(@y,@ys),@x) = [1] @ys + [10] >= [1] @ys + [10] = group3#3(@ys,@x,@y) group3#2(nil(),@x) = [2] >= [0] = nil() group3#3(::(@z,@zs),@x,@y) = [1] @zs + [18] >= [1] @zs + [13] = ::(tuple#3(@x,@y,@z),group3(@zs)) group3#3(nil(),@x,@y) = [10] >= [0] = nil() zip3(@l1,@l2,@l3) = [1] @l1 + [1] @l3 + [4] >= [1] @l1 + [1] @l3 + [0] = zip3#1(@l1,@l2,@l3) zip3#1(::(@x,@xs),@l2,@l3) = [1] @l3 + [1] @xs + [8] >= [1] @l3 + [1] @xs + [8] = zip3#2(@l2,@l3,@x,@xs) zip3#1(nil(),@l2,@l3) = [1] @l3 + [0] >= [0] = nil() zip3#2(::(@y,@ys),@l3,@x,@xs) = [1] @l3 + [1] @xs + [8] >= [1] @l3 + [1] @xs + [8] = zip3#3(@l3,@x,@xs,@y,@ys) zip3#2(nil(),@l3,@x,@xs) = [1] @l3 + [1] @xs + [8] >= [0] = nil() zip3#3(nil(),@x,@xs,@y,@ys) = [1] @xs + [8] >= [0] = nil() * Step 5: EmptyProcessor. WORST_CASE(?,O(1)) + Considered Problem: - Weak TRS: group3(@l) -> group3#1(@l) group3#1(::(@x,@xs)) -> group3#2(@xs,@x) group3#1(nil()) -> nil() group3#2(::(@y,@ys),@x) -> group3#3(@ys,@x,@y) group3#2(nil(),@x) -> nil() group3#3(::(@z,@zs),@x,@y) -> ::(tuple#3(@x,@y,@z),group3(@zs)) group3#3(nil(),@x,@y) -> nil() zip3(@l1,@l2,@l3) -> zip3#1(@l1,@l2,@l3) zip3#1(::(@x,@xs),@l2,@l3) -> zip3#2(@l2,@l3,@x,@xs) zip3#1(nil(),@l2,@l3) -> nil() zip3#2(::(@y,@ys),@l3,@x,@xs) -> zip3#3(@l3,@x,@xs,@y,@ys) zip3#2(nil(),@l3,@x,@xs) -> nil() zip3#3(::(@z,@zs),@x,@xs,@y,@ys) -> ::(tuple#3(@x,@y,@z),zip3(@xs,@ys,@zs)) zip3#3(nil(),@x,@xs,@y,@ys) -> nil() - Signature: {group3/1,group3#1/1,group3#2/2,group3#3/3,zip3/3,zip3#1/3,zip3#2/4,zip3#3/5} / {::/2,nil/0,tuple#3/3} - Obligation: innermost runtime complexity wrt. defined symbols {group3,group3#1,group3#2,group3#3,zip3,zip3#1,zip3#2 ,zip3#3} and constructors {::,nil,tuple#3} + Applied Processor: EmptyProcessor + Details: The problem is already closed. The intended complexity is O(1). WORST_CASE(?,O(n^1))