/export/starexec/sandbox2/solver/bin/starexec_run_standard /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/output/output_files -------------------------------------------------------------------------------- YES proof of /export/starexec/sandbox2/benchmark/theBenchmark.xml # AProVE Commit ID: 48fb2092695e11cc9f56e44b17a92a5f88ffb256 marcel 20180622 unpublished dirty Termination w.r.t. Q of the given QTRS could be proven: (0) QTRS (1) QTRSRRRProof [EQUIVALENT, 192 ms] (2) QTRS (3) QTRSRRRProof [EQUIVALENT, 82 ms] (4) QTRS (5) QTRSRRRProof [EQUIVALENT, 101 ms] (6) QTRS (7) DependencyPairsProof [EQUIVALENT, 30 ms] (8) QDP (9) DependencyGraphProof [EQUIVALENT, 0 ms] (10) AND (11) QDP (12) UsableRulesProof [EQUIVALENT, 0 ms] (13) QDP (14) QDPSizeChangeProof [EQUIVALENT, 0 ms] (15) YES (16) QDP (17) UsableRulesProof [EQUIVALENT, 0 ms] (18) QDP (19) QDPSizeChangeProof [EQUIVALENT, 0 ms] (20) YES (21) QDP (22) UsableRulesProof [EQUIVALENT, 0 ms] (23) QDP (24) QDPSizeChangeProof [EQUIVALENT, 0 ms] (25) YES (26) QDP (27) UsableRulesProof [EQUIVALENT, 0 ms] (28) QDP (29) QDPSizeChangeProof [EQUIVALENT, 0 ms] (30) YES (31) QDP (32) UsableRulesProof [EQUIVALENT, 0 ms] (33) QDP (34) QDPSizeChangeProof [EQUIVALENT, 0 ms] (35) YES (36) QDP (37) UsableRulesProof [EQUIVALENT, 0 ms] (38) QDP (39) QDPSizeChangeProof [EQUIVALENT, 0 ms] (40) YES (41) QDP (42) UsableRulesProof [EQUIVALENT, 0 ms] (43) QDP (44) QDPSizeChangeProof [EQUIVALENT, 0 ms] (45) YES (46) QDP (47) UsableRulesProof [EQUIVALENT, 0 ms] (48) QDP (49) QDPSizeChangeProof [EQUIVALENT, 0 ms] (50) YES (51) QDP (52) MRRProof [EQUIVALENT, 155 ms] (53) QDP (54) MRRProof [EQUIVALENT, 146 ms] (55) QDP (56) MRRProof [EQUIVALENT, 99 ms] (57) QDP (58) MRRProof [EQUIVALENT, 119 ms] (59) QDP (60) QDPOrderProof [EQUIVALENT, 196 ms] (61) QDP (62) DependencyGraphProof [EQUIVALENT, 0 ms] (63) QDP (64) QDPOrderProof [EQUIVALENT, 63 ms] (65) QDP (66) QDPOrderProof [EQUIVALENT, 92 ms] (67) QDP (68) QDPOrderProof [EQUIVALENT, 179 ms] (69) QDP (70) QDPOrderProof [EQUIVALENT, 168 ms] (71) QDP (72) DependencyGraphProof [EQUIVALENT, 0 ms] (73) QDP (74) UsableRulesProof [EQUIVALENT, 0 ms] (75) QDP (76) QDPSizeChangeProof [EQUIVALENT, 0 ms] (77) YES ---------------------------------------- (0) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(0, XS)) -> mark(nil) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(nil, XS)) -> mark(nil) active(zip(X, nil)) -> mark(nil) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(tail(cons(X, XS))) -> mark(XS) active(repItems(nil)) -> mark(nil) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. ---------------------------------------- (1) QTRSRRRProof (EQUIVALENT) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(active(x_1)) = x_1 POL(cons(x_1, x_2)) = x_1 + x_2 POL(incr(x_1)) = 2*x_1 POL(mark(x_1)) = x_1 POL(nil) = 0 POL(oddNs) = 0 POL(pair(x_1, x_2)) = x_1 + x_2 POL(pairNs) = 0 POL(repItems(x_1)) = 2*x_1 POL(s(x_1)) = x_1 POL(tail(x_1)) = 2 + 2*x_1 POL(take(x_1, x_2)) = x_1 + x_2 POL(zip(x_1, x_2)) = 2*x_1 + 2*x_2 With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly: active(tail(cons(X, XS))) -> mark(XS) ---------------------------------------- (2) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(0, XS)) -> mark(nil) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(nil, XS)) -> mark(nil) active(zip(X, nil)) -> mark(nil) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(repItems(nil)) -> mark(nil) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. ---------------------------------------- (3) QTRSRRRProof (EQUIVALENT) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(active(x_1)) = x_1 POL(cons(x_1, x_2)) = x_1 + x_2 POL(incr(x_1)) = 2*x_1 POL(mark(x_1)) = x_1 POL(nil) = 0 POL(oddNs) = 0 POL(pair(x_1, x_2)) = x_1 + x_2 POL(pairNs) = 0 POL(repItems(x_1)) = 2*x_1 POL(s(x_1)) = 2*x_1 POL(tail(x_1)) = x_1 POL(take(x_1, x_2)) = 1 + 2*x_1 + 2*x_2 POL(zip(x_1, x_2)) = 2*x_1 + x_2 With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly: active(take(0, XS)) -> mark(nil) ---------------------------------------- (4) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(nil, XS)) -> mark(nil) active(zip(X, nil)) -> mark(nil) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(repItems(nil)) -> mark(nil) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. ---------------------------------------- (5) QTRSRRRProof (EQUIVALENT) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(active(x_1)) = x_1 POL(cons(x_1, x_2)) = 2*x_1 + x_2 POL(incr(x_1)) = 2*x_1 POL(mark(x_1)) = x_1 POL(nil) = 2 POL(oddNs) = 0 POL(pair(x_1, x_2)) = x_1 + x_2 POL(pairNs) = 0 POL(repItems(x_1)) = 2*x_1 POL(s(x_1)) = x_1 POL(tail(x_1)) = x_1 POL(take(x_1, x_2)) = 2*x_1 + x_2 POL(zip(x_1, x_2)) = 2*x_1 + 2*x_2 With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly: active(zip(nil, XS)) -> mark(nil) active(zip(X, nil)) -> mark(nil) active(repItems(nil)) -> mark(nil) ---------------------------------------- (6) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. ---------------------------------------- (7) DependencyPairsProof (EQUIVALENT) Using Dependency Pairs [AG00,LPAR04] we result in the following initial DP problem. ---------------------------------------- (8) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(pairNs) -> MARK(cons(0, incr(oddNs))) ACTIVE(pairNs) -> CONS(0, incr(oddNs)) ACTIVE(pairNs) -> INCR(oddNs) ACTIVE(oddNs) -> MARK(incr(pairNs)) ACTIVE(oddNs) -> INCR(pairNs) ACTIVE(incr(cons(X, XS))) -> MARK(cons(s(X), incr(XS))) ACTIVE(incr(cons(X, XS))) -> CONS(s(X), incr(XS)) ACTIVE(incr(cons(X, XS))) -> S(X) ACTIVE(incr(cons(X, XS))) -> INCR(XS) ACTIVE(take(s(N), cons(X, XS))) -> MARK(cons(X, take(N, XS))) ACTIVE(take(s(N), cons(X, XS))) -> CONS(X, take(N, XS)) ACTIVE(take(s(N), cons(X, XS))) -> TAKE(N, XS) ACTIVE(zip(cons(X, XS), cons(Y, YS))) -> MARK(cons(pair(X, Y), zip(XS, YS))) ACTIVE(zip(cons(X, XS), cons(Y, YS))) -> CONS(pair(X, Y), zip(XS, YS)) ACTIVE(zip(cons(X, XS), cons(Y, YS))) -> PAIR(X, Y) ACTIVE(zip(cons(X, XS), cons(Y, YS))) -> ZIP(XS, YS) ACTIVE(repItems(cons(X, XS))) -> MARK(cons(X, cons(X, repItems(XS)))) ACTIVE(repItems(cons(X, XS))) -> CONS(X, cons(X, repItems(XS))) ACTIVE(repItems(cons(X, XS))) -> CONS(X, repItems(XS)) ACTIVE(repItems(cons(X, XS))) -> REPITEMS(XS) MARK(pairNs) -> ACTIVE(pairNs) MARK(cons(X1, X2)) -> ACTIVE(cons(mark(X1), X2)) MARK(cons(X1, X2)) -> CONS(mark(X1), X2) MARK(cons(X1, X2)) -> MARK(X1) MARK(0) -> ACTIVE(0) MARK(incr(X)) -> ACTIVE(incr(mark(X))) MARK(incr(X)) -> INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(oddNs) -> ACTIVE(oddNs) MARK(s(X)) -> ACTIVE(s(mark(X))) MARK(s(X)) -> S(mark(X)) MARK(s(X)) -> MARK(X) MARK(take(X1, X2)) -> ACTIVE(take(mark(X1), mark(X2))) MARK(take(X1, X2)) -> TAKE(mark(X1), mark(X2)) MARK(take(X1, X2)) -> MARK(X1) MARK(take(X1, X2)) -> MARK(X2) MARK(nil) -> ACTIVE(nil) MARK(zip(X1, X2)) -> ACTIVE(zip(mark(X1), mark(X2))) MARK(zip(X1, X2)) -> ZIP(mark(X1), mark(X2)) MARK(zip(X1, X2)) -> MARK(X1) MARK(zip(X1, X2)) -> MARK(X2) MARK(pair(X1, X2)) -> ACTIVE(pair(mark(X1), mark(X2))) MARK(pair(X1, X2)) -> PAIR(mark(X1), mark(X2)) MARK(pair(X1, X2)) -> MARK(X1) MARK(pair(X1, X2)) -> MARK(X2) MARK(tail(X)) -> ACTIVE(tail(mark(X))) MARK(tail(X)) -> TAIL(mark(X)) MARK(tail(X)) -> MARK(X) MARK(repItems(X)) -> ACTIVE(repItems(mark(X))) MARK(repItems(X)) -> REPITEMS(mark(X)) MARK(repItems(X)) -> MARK(X) CONS(mark(X1), X2) -> CONS(X1, X2) CONS(X1, mark(X2)) -> CONS(X1, X2) CONS(active(X1), X2) -> CONS(X1, X2) CONS(X1, active(X2)) -> CONS(X1, X2) INCR(mark(X)) -> INCR(X) INCR(active(X)) -> INCR(X) S(mark(X)) -> S(X) S(active(X)) -> S(X) TAKE(mark(X1), X2) -> TAKE(X1, X2) TAKE(X1, mark(X2)) -> TAKE(X1, X2) TAKE(active(X1), X2) -> TAKE(X1, X2) TAKE(X1, active(X2)) -> TAKE(X1, X2) ZIP(mark(X1), X2) -> ZIP(X1, X2) ZIP(X1, mark(X2)) -> ZIP(X1, X2) ZIP(active(X1), X2) -> ZIP(X1, X2) ZIP(X1, active(X2)) -> ZIP(X1, X2) PAIR(mark(X1), X2) -> PAIR(X1, X2) PAIR(X1, mark(X2)) -> PAIR(X1, X2) PAIR(active(X1), X2) -> PAIR(X1, X2) PAIR(X1, active(X2)) -> PAIR(X1, X2) TAIL(mark(X)) -> TAIL(X) TAIL(active(X)) -> TAIL(X) REPITEMS(mark(X)) -> REPITEMS(X) REPITEMS(active(X)) -> REPITEMS(X) The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (9) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 9 SCCs with 24 less nodes. ---------------------------------------- (10) Complex Obligation (AND) ---------------------------------------- (11) Obligation: Q DP problem: The TRS P consists of the following rules: REPITEMS(active(X)) -> REPITEMS(X) REPITEMS(mark(X)) -> REPITEMS(X) The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (12) UsableRulesProof (EQUIVALENT) We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (13) Obligation: Q DP problem: The TRS P consists of the following rules: REPITEMS(active(X)) -> REPITEMS(X) REPITEMS(mark(X)) -> REPITEMS(X) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (14) QDPSizeChangeProof (EQUIVALENT) By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. From the DPs we obtained the following set of size-change graphs: *REPITEMS(active(X)) -> REPITEMS(X) The graph contains the following edges 1 > 1 *REPITEMS(mark(X)) -> REPITEMS(X) The graph contains the following edges 1 > 1 ---------------------------------------- (15) YES ---------------------------------------- (16) Obligation: Q DP problem: The TRS P consists of the following rules: TAIL(active(X)) -> TAIL(X) TAIL(mark(X)) -> TAIL(X) The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (17) UsableRulesProof (EQUIVALENT) We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (18) Obligation: Q DP problem: The TRS P consists of the following rules: TAIL(active(X)) -> TAIL(X) TAIL(mark(X)) -> TAIL(X) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (19) QDPSizeChangeProof (EQUIVALENT) By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. From the DPs we obtained the following set of size-change graphs: *TAIL(active(X)) -> TAIL(X) The graph contains the following edges 1 > 1 *TAIL(mark(X)) -> TAIL(X) The graph contains the following edges 1 > 1 ---------------------------------------- (20) YES ---------------------------------------- (21) Obligation: Q DP problem: The TRS P consists of the following rules: PAIR(X1, mark(X2)) -> PAIR(X1, X2) PAIR(mark(X1), X2) -> PAIR(X1, X2) PAIR(active(X1), X2) -> PAIR(X1, X2) PAIR(X1, active(X2)) -> PAIR(X1, X2) The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (22) UsableRulesProof (EQUIVALENT) We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (23) Obligation: Q DP problem: The TRS P consists of the following rules: PAIR(X1, mark(X2)) -> PAIR(X1, X2) PAIR(mark(X1), X2) -> PAIR(X1, X2) PAIR(active(X1), X2) -> PAIR(X1, X2) PAIR(X1, active(X2)) -> PAIR(X1, X2) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (24) QDPSizeChangeProof (EQUIVALENT) By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. From the DPs we obtained the following set of size-change graphs: *PAIR(X1, mark(X2)) -> PAIR(X1, X2) The graph contains the following edges 1 >= 1, 2 > 2 *PAIR(mark(X1), X2) -> PAIR(X1, X2) The graph contains the following edges 1 > 1, 2 >= 2 *PAIR(active(X1), X2) -> PAIR(X1, X2) The graph contains the following edges 1 > 1, 2 >= 2 *PAIR(X1, active(X2)) -> PAIR(X1, X2) The graph contains the following edges 1 >= 1, 2 > 2 ---------------------------------------- (25) YES ---------------------------------------- (26) Obligation: Q DP problem: The TRS P consists of the following rules: ZIP(X1, mark(X2)) -> ZIP(X1, X2) ZIP(mark(X1), X2) -> ZIP(X1, X2) ZIP(active(X1), X2) -> ZIP(X1, X2) ZIP(X1, active(X2)) -> ZIP(X1, X2) The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (27) UsableRulesProof (EQUIVALENT) We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (28) Obligation: Q DP problem: The TRS P consists of the following rules: ZIP(X1, mark(X2)) -> ZIP(X1, X2) ZIP(mark(X1), X2) -> ZIP(X1, X2) ZIP(active(X1), X2) -> ZIP(X1, X2) ZIP(X1, active(X2)) -> ZIP(X1, X2) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (29) QDPSizeChangeProof (EQUIVALENT) By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. From the DPs we obtained the following set of size-change graphs: *ZIP(X1, mark(X2)) -> ZIP(X1, X2) The graph contains the following edges 1 >= 1, 2 > 2 *ZIP(mark(X1), X2) -> ZIP(X1, X2) The graph contains the following edges 1 > 1, 2 >= 2 *ZIP(active(X1), X2) -> ZIP(X1, X2) The graph contains the following edges 1 > 1, 2 >= 2 *ZIP(X1, active(X2)) -> ZIP(X1, X2) The graph contains the following edges 1 >= 1, 2 > 2 ---------------------------------------- (30) YES ---------------------------------------- (31) Obligation: Q DP problem: The TRS P consists of the following rules: TAKE(X1, mark(X2)) -> TAKE(X1, X2) TAKE(mark(X1), X2) -> TAKE(X1, X2) TAKE(active(X1), X2) -> TAKE(X1, X2) TAKE(X1, active(X2)) -> TAKE(X1, X2) The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (32) UsableRulesProof (EQUIVALENT) We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (33) Obligation: Q DP problem: The TRS P consists of the following rules: TAKE(X1, mark(X2)) -> TAKE(X1, X2) TAKE(mark(X1), X2) -> TAKE(X1, X2) TAKE(active(X1), X2) -> TAKE(X1, X2) TAKE(X1, active(X2)) -> TAKE(X1, X2) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (34) QDPSizeChangeProof (EQUIVALENT) By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. From the DPs we obtained the following set of size-change graphs: *TAKE(X1, mark(X2)) -> TAKE(X1, X2) The graph contains the following edges 1 >= 1, 2 > 2 *TAKE(mark(X1), X2) -> TAKE(X1, X2) The graph contains the following edges 1 > 1, 2 >= 2 *TAKE(active(X1), X2) -> TAKE(X1, X2) The graph contains the following edges 1 > 1, 2 >= 2 *TAKE(X1, active(X2)) -> TAKE(X1, X2) The graph contains the following edges 1 >= 1, 2 > 2 ---------------------------------------- (35) YES ---------------------------------------- (36) Obligation: Q DP problem: The TRS P consists of the following rules: S(active(X)) -> S(X) S(mark(X)) -> S(X) The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (37) UsableRulesProof (EQUIVALENT) We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (38) Obligation: Q DP problem: The TRS P consists of the following rules: S(active(X)) -> S(X) S(mark(X)) -> S(X) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (39) QDPSizeChangeProof (EQUIVALENT) By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. From the DPs we obtained the following set of size-change graphs: *S(active(X)) -> S(X) The graph contains the following edges 1 > 1 *S(mark(X)) -> S(X) The graph contains the following edges 1 > 1 ---------------------------------------- (40) YES ---------------------------------------- (41) Obligation: Q DP problem: The TRS P consists of the following rules: INCR(active(X)) -> INCR(X) INCR(mark(X)) -> INCR(X) The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (42) UsableRulesProof (EQUIVALENT) We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (43) Obligation: Q DP problem: The TRS P consists of the following rules: INCR(active(X)) -> INCR(X) INCR(mark(X)) -> INCR(X) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (44) QDPSizeChangeProof (EQUIVALENT) By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. From the DPs we obtained the following set of size-change graphs: *INCR(active(X)) -> INCR(X) The graph contains the following edges 1 > 1 *INCR(mark(X)) -> INCR(X) The graph contains the following edges 1 > 1 ---------------------------------------- (45) YES ---------------------------------------- (46) Obligation: Q DP problem: The TRS P consists of the following rules: CONS(X1, mark(X2)) -> CONS(X1, X2) CONS(mark(X1), X2) -> CONS(X1, X2) CONS(active(X1), X2) -> CONS(X1, X2) CONS(X1, active(X2)) -> CONS(X1, X2) The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (47) UsableRulesProof (EQUIVALENT) We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (48) Obligation: Q DP problem: The TRS P consists of the following rules: CONS(X1, mark(X2)) -> CONS(X1, X2) CONS(mark(X1), X2) -> CONS(X1, X2) CONS(active(X1), X2) -> CONS(X1, X2) CONS(X1, active(X2)) -> CONS(X1, X2) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (49) QDPSizeChangeProof (EQUIVALENT) By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. From the DPs we obtained the following set of size-change graphs: *CONS(X1, mark(X2)) -> CONS(X1, X2) The graph contains the following edges 1 >= 1, 2 > 2 *CONS(mark(X1), X2) -> CONS(X1, X2) The graph contains the following edges 1 > 1, 2 >= 2 *CONS(active(X1), X2) -> CONS(X1, X2) The graph contains the following edges 1 > 1, 2 >= 2 *CONS(X1, active(X2)) -> CONS(X1, X2) The graph contains the following edges 1 >= 1, 2 > 2 ---------------------------------------- (50) YES ---------------------------------------- (51) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(cons(X1, X2)) -> ACTIVE(cons(mark(X1), X2)) ACTIVE(incr(cons(X, XS))) -> MARK(cons(s(X), incr(XS))) MARK(cons(X1, X2)) -> MARK(X1) MARK(pairNs) -> ACTIVE(pairNs) ACTIVE(pairNs) -> MARK(cons(0, incr(oddNs))) MARK(incr(X)) -> ACTIVE(incr(mark(X))) ACTIVE(take(s(N), cons(X, XS))) -> MARK(cons(X, take(N, XS))) MARK(incr(X)) -> MARK(X) MARK(oddNs) -> ACTIVE(oddNs) ACTIVE(oddNs) -> MARK(incr(pairNs)) MARK(s(X)) -> ACTIVE(s(mark(X))) ACTIVE(zip(cons(X, XS), cons(Y, YS))) -> MARK(cons(pair(X, Y), zip(XS, YS))) MARK(s(X)) -> MARK(X) MARK(take(X1, X2)) -> ACTIVE(take(mark(X1), mark(X2))) ACTIVE(repItems(cons(X, XS))) -> MARK(cons(X, cons(X, repItems(XS)))) MARK(take(X1, X2)) -> MARK(X1) MARK(take(X1, X2)) -> MARK(X2) MARK(zip(X1, X2)) -> ACTIVE(zip(mark(X1), mark(X2))) MARK(zip(X1, X2)) -> MARK(X1) MARK(zip(X1, X2)) -> MARK(X2) MARK(pair(X1, X2)) -> ACTIVE(pair(mark(X1), mark(X2))) MARK(pair(X1, X2)) -> MARK(X1) MARK(pair(X1, X2)) -> MARK(X2) MARK(tail(X)) -> ACTIVE(tail(mark(X))) MARK(tail(X)) -> MARK(X) MARK(repItems(X)) -> ACTIVE(repItems(mark(X))) MARK(repItems(X)) -> MARK(X) The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (52) MRRProof (EQUIVALENT) By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented. Strictly oriented dependency pairs: MARK(take(X1, X2)) -> MARK(X1) MARK(take(X1, X2)) -> MARK(X2) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVE(x_1)) = 2*x_1 POL(MARK(x_1)) = 2*x_1 POL(active(x_1)) = x_1 POL(cons(x_1, x_2)) = x_1 + x_2 POL(incr(x_1)) = x_1 POL(mark(x_1)) = x_1 POL(nil) = 0 POL(oddNs) = 0 POL(pair(x_1, x_2)) = x_1 + x_2 POL(pairNs) = 0 POL(repItems(x_1)) = 2*x_1 POL(s(x_1)) = x_1 POL(tail(x_1)) = 2*x_1 POL(take(x_1, x_2)) = 2 + x_1 + x_2 POL(zip(x_1, x_2)) = x_1 + 2*x_2 ---------------------------------------- (53) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(cons(X1, X2)) -> ACTIVE(cons(mark(X1), X2)) ACTIVE(incr(cons(X, XS))) -> MARK(cons(s(X), incr(XS))) MARK(cons(X1, X2)) -> MARK(X1) MARK(pairNs) -> ACTIVE(pairNs) ACTIVE(pairNs) -> MARK(cons(0, incr(oddNs))) MARK(incr(X)) -> ACTIVE(incr(mark(X))) ACTIVE(take(s(N), cons(X, XS))) -> MARK(cons(X, take(N, XS))) MARK(incr(X)) -> MARK(X) MARK(oddNs) -> ACTIVE(oddNs) ACTIVE(oddNs) -> MARK(incr(pairNs)) MARK(s(X)) -> ACTIVE(s(mark(X))) ACTIVE(zip(cons(X, XS), cons(Y, YS))) -> MARK(cons(pair(X, Y), zip(XS, YS))) MARK(s(X)) -> MARK(X) MARK(take(X1, X2)) -> ACTIVE(take(mark(X1), mark(X2))) ACTIVE(repItems(cons(X, XS))) -> MARK(cons(X, cons(X, repItems(XS)))) MARK(zip(X1, X2)) -> ACTIVE(zip(mark(X1), mark(X2))) MARK(zip(X1, X2)) -> MARK(X1) MARK(zip(X1, X2)) -> MARK(X2) MARK(pair(X1, X2)) -> ACTIVE(pair(mark(X1), mark(X2))) MARK(pair(X1, X2)) -> MARK(X1) MARK(pair(X1, X2)) -> MARK(X2) MARK(tail(X)) -> ACTIVE(tail(mark(X))) MARK(tail(X)) -> MARK(X) MARK(repItems(X)) -> ACTIVE(repItems(mark(X))) MARK(repItems(X)) -> MARK(X) The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (54) MRRProof (EQUIVALENT) By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented. Strictly oriented dependency pairs: MARK(tail(X)) -> MARK(X) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVE(x_1)) = x_1 POL(MARK(x_1)) = x_1 POL(active(x_1)) = x_1 POL(cons(x_1, x_2)) = x_1 + x_2 POL(incr(x_1)) = 2*x_1 POL(mark(x_1)) = x_1 POL(nil) = 0 POL(oddNs) = 0 POL(pair(x_1, x_2)) = x_1 + 2*x_2 POL(pairNs) = 0 POL(repItems(x_1)) = 2*x_1 POL(s(x_1)) = x_1 POL(tail(x_1)) = 2 + x_1 POL(take(x_1, x_2)) = x_1 + x_2 POL(zip(x_1, x_2)) = 2*x_1 + 2*x_2 ---------------------------------------- (55) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(cons(X1, X2)) -> ACTIVE(cons(mark(X1), X2)) ACTIVE(incr(cons(X, XS))) -> MARK(cons(s(X), incr(XS))) MARK(cons(X1, X2)) -> MARK(X1) MARK(pairNs) -> ACTIVE(pairNs) ACTIVE(pairNs) -> MARK(cons(0, incr(oddNs))) MARK(incr(X)) -> ACTIVE(incr(mark(X))) ACTIVE(take(s(N), cons(X, XS))) -> MARK(cons(X, take(N, XS))) MARK(incr(X)) -> MARK(X) MARK(oddNs) -> ACTIVE(oddNs) ACTIVE(oddNs) -> MARK(incr(pairNs)) MARK(s(X)) -> ACTIVE(s(mark(X))) ACTIVE(zip(cons(X, XS), cons(Y, YS))) -> MARK(cons(pair(X, Y), zip(XS, YS))) MARK(s(X)) -> MARK(X) MARK(take(X1, X2)) -> ACTIVE(take(mark(X1), mark(X2))) ACTIVE(repItems(cons(X, XS))) -> MARK(cons(X, cons(X, repItems(XS)))) MARK(zip(X1, X2)) -> ACTIVE(zip(mark(X1), mark(X2))) MARK(zip(X1, X2)) -> MARK(X1) MARK(zip(X1, X2)) -> MARK(X2) MARK(pair(X1, X2)) -> ACTIVE(pair(mark(X1), mark(X2))) MARK(pair(X1, X2)) -> MARK(X1) MARK(pair(X1, X2)) -> MARK(X2) MARK(tail(X)) -> ACTIVE(tail(mark(X))) MARK(repItems(X)) -> ACTIVE(repItems(mark(X))) MARK(repItems(X)) -> MARK(X) The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (56) MRRProof (EQUIVALENT) By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented. Strictly oriented dependency pairs: MARK(zip(X1, X2)) -> MARK(X1) MARK(zip(X1, X2)) -> MARK(X2) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVE(x_1)) = 2*x_1 POL(MARK(x_1)) = 2*x_1 POL(active(x_1)) = x_1 POL(cons(x_1, x_2)) = 2*x_1 + x_2 POL(incr(x_1)) = x_1 POL(mark(x_1)) = x_1 POL(nil) = 0 POL(oddNs) = 0 POL(pair(x_1, x_2)) = 2*x_1 + 2*x_2 POL(pairNs) = 0 POL(repItems(x_1)) = 2*x_1 POL(s(x_1)) = x_1 POL(tail(x_1)) = 2*x_1 POL(take(x_1, x_2)) = 2*x_1 + x_2 POL(zip(x_1, x_2)) = 2 + 2*x_1 + 2*x_2 ---------------------------------------- (57) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(cons(X1, X2)) -> ACTIVE(cons(mark(X1), X2)) ACTIVE(incr(cons(X, XS))) -> MARK(cons(s(X), incr(XS))) MARK(cons(X1, X2)) -> MARK(X1) MARK(pairNs) -> ACTIVE(pairNs) ACTIVE(pairNs) -> MARK(cons(0, incr(oddNs))) MARK(incr(X)) -> ACTIVE(incr(mark(X))) ACTIVE(take(s(N), cons(X, XS))) -> MARK(cons(X, take(N, XS))) MARK(incr(X)) -> MARK(X) MARK(oddNs) -> ACTIVE(oddNs) ACTIVE(oddNs) -> MARK(incr(pairNs)) MARK(s(X)) -> ACTIVE(s(mark(X))) ACTIVE(zip(cons(X, XS), cons(Y, YS))) -> MARK(cons(pair(X, Y), zip(XS, YS))) MARK(s(X)) -> MARK(X) MARK(take(X1, X2)) -> ACTIVE(take(mark(X1), mark(X2))) ACTIVE(repItems(cons(X, XS))) -> MARK(cons(X, cons(X, repItems(XS)))) MARK(zip(X1, X2)) -> ACTIVE(zip(mark(X1), mark(X2))) MARK(pair(X1, X2)) -> ACTIVE(pair(mark(X1), mark(X2))) MARK(pair(X1, X2)) -> MARK(X1) MARK(pair(X1, X2)) -> MARK(X2) MARK(tail(X)) -> ACTIVE(tail(mark(X))) MARK(repItems(X)) -> ACTIVE(repItems(mark(X))) MARK(repItems(X)) -> MARK(X) The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (58) MRRProof (EQUIVALENT) By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented. Strictly oriented dependency pairs: MARK(repItems(X)) -> MARK(X) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVE(x_1)) = x_1 POL(MARK(x_1)) = x_1 POL(active(x_1)) = x_1 POL(cons(x_1, x_2)) = 2*x_1 + x_2 POL(incr(x_1)) = 2*x_1 POL(mark(x_1)) = x_1 POL(nil) = 0 POL(oddNs) = 0 POL(pair(x_1, x_2)) = 2*x_1 + x_2 POL(pairNs) = 0 POL(repItems(x_1)) = 1 + 2*x_1 POL(s(x_1)) = x_1 POL(tail(x_1)) = 2*x_1 POL(take(x_1, x_2)) = x_1 + 2*x_2 POL(zip(x_1, x_2)) = 2*x_1 + 2*x_2 ---------------------------------------- (59) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(cons(X1, X2)) -> ACTIVE(cons(mark(X1), X2)) ACTIVE(incr(cons(X, XS))) -> MARK(cons(s(X), incr(XS))) MARK(cons(X1, X2)) -> MARK(X1) MARK(pairNs) -> ACTIVE(pairNs) ACTIVE(pairNs) -> MARK(cons(0, incr(oddNs))) MARK(incr(X)) -> ACTIVE(incr(mark(X))) ACTIVE(take(s(N), cons(X, XS))) -> MARK(cons(X, take(N, XS))) MARK(incr(X)) -> MARK(X) MARK(oddNs) -> ACTIVE(oddNs) ACTIVE(oddNs) -> MARK(incr(pairNs)) MARK(s(X)) -> ACTIVE(s(mark(X))) ACTIVE(zip(cons(X, XS), cons(Y, YS))) -> MARK(cons(pair(X, Y), zip(XS, YS))) MARK(s(X)) -> MARK(X) MARK(take(X1, X2)) -> ACTIVE(take(mark(X1), mark(X2))) ACTIVE(repItems(cons(X, XS))) -> MARK(cons(X, cons(X, repItems(XS)))) MARK(zip(X1, X2)) -> ACTIVE(zip(mark(X1), mark(X2))) MARK(pair(X1, X2)) -> ACTIVE(pair(mark(X1), mark(X2))) MARK(pair(X1, X2)) -> MARK(X1) MARK(pair(X1, X2)) -> MARK(X2) MARK(tail(X)) -> ACTIVE(tail(mark(X))) MARK(repItems(X)) -> ACTIVE(repItems(mark(X))) The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (60) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. ACTIVE(pairNs) -> MARK(cons(0, incr(oddNs))) ACTIVE(oddNs) -> MARK(incr(pairNs)) ACTIVE(zip(cons(X, XS), cons(Y, YS))) -> MARK(cons(pair(X, Y), zip(XS, YS))) MARK(pair(X1, X2)) -> MARK(X1) MARK(pair(X1, X2)) -> MARK(X2) The remaining pairs can at least be oriented weakly. Used ordering: Combined order from the following AFS and order. MARK(x1) = x1 cons(x1, x2) = x1 ACTIVE(x1) = x1 mark(x1) = x1 incr(x1) = x1 s(x1) = x1 pairNs = pairNs 0 = 0 take(x1, x2) = x2 oddNs = oddNs zip(x1, x2) = zip(x1, x2) pair(x1, x2) = pair(x1, x2) repItems(x1) = x1 tail(x1) = tail active(x1) = x1 nil = nil Knuth-Bendix order [KBO] with precedence:oddNs > pairNs > 0 and weight map: oddNs=1 tail=2 zip_2=2 0=1 pair_2=1 pairNs=1 nil=2 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) mark(incr(X)) -> active(incr(mark(X))) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) mark(pairNs) -> active(pairNs) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) mark(0) -> active(0) mark(nil) -> active(nil) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) incr(active(X)) -> incr(X) incr(mark(X)) -> incr(X) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) repItems(active(X)) -> repItems(X) repItems(mark(X)) -> repItems(X) tail(active(X)) -> tail(X) tail(mark(X)) -> tail(X) ---------------------------------------- (61) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(cons(X1, X2)) -> ACTIVE(cons(mark(X1), X2)) ACTIVE(incr(cons(X, XS))) -> MARK(cons(s(X), incr(XS))) MARK(cons(X1, X2)) -> MARK(X1) MARK(pairNs) -> ACTIVE(pairNs) MARK(incr(X)) -> ACTIVE(incr(mark(X))) ACTIVE(take(s(N), cons(X, XS))) -> MARK(cons(X, take(N, XS))) MARK(incr(X)) -> MARK(X) MARK(oddNs) -> ACTIVE(oddNs) MARK(s(X)) -> ACTIVE(s(mark(X))) MARK(s(X)) -> MARK(X) MARK(take(X1, X2)) -> ACTIVE(take(mark(X1), mark(X2))) ACTIVE(repItems(cons(X, XS))) -> MARK(cons(X, cons(X, repItems(XS)))) MARK(zip(X1, X2)) -> ACTIVE(zip(mark(X1), mark(X2))) MARK(pair(X1, X2)) -> ACTIVE(pair(mark(X1), mark(X2))) MARK(tail(X)) -> ACTIVE(tail(mark(X))) MARK(repItems(X)) -> ACTIVE(repItems(mark(X))) The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (62) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes. ---------------------------------------- (63) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(incr(cons(X, XS))) -> MARK(cons(s(X), incr(XS))) MARK(cons(X1, X2)) -> ACTIVE(cons(mark(X1), X2)) ACTIVE(take(s(N), cons(X, XS))) -> MARK(cons(X, take(N, XS))) MARK(cons(X1, X2)) -> MARK(X1) MARK(incr(X)) -> ACTIVE(incr(mark(X))) ACTIVE(repItems(cons(X, XS))) -> MARK(cons(X, cons(X, repItems(XS)))) MARK(incr(X)) -> MARK(X) MARK(s(X)) -> ACTIVE(s(mark(X))) MARK(s(X)) -> MARK(X) MARK(take(X1, X2)) -> ACTIVE(take(mark(X1), mark(X2))) MARK(zip(X1, X2)) -> ACTIVE(zip(mark(X1), mark(X2))) MARK(pair(X1, X2)) -> ACTIVE(pair(mark(X1), mark(X2))) MARK(tail(X)) -> ACTIVE(tail(mark(X))) MARK(repItems(X)) -> ACTIVE(repItems(mark(X))) The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (64) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. ACTIVE(repItems(cons(X, XS))) -> MARK(cons(X, cons(X, repItems(XS)))) The remaining pairs can at least be oriented weakly. Used ordering: Combined order from the following AFS and order. ACTIVE(x1) = x1 incr(x1) = x1 cons(x1, x2) = x1 MARK(x1) = x1 s(x1) = x1 mark(x1) = x1 take(x1, x2) = x2 repItems(x1) = repItems(x1) zip(x1, x2) = zip pair(x1, x2) = pair tail(x1) = tail active(x1) = x1 pairNs = pairNs 0 = 0 oddNs = oddNs nil = nil Knuth-Bendix order [KBO] with precedence:oddNs > pairNs > 0 and weight map: oddNs=1 tail=2 zip=3 0=1 pair=2 pairNs=1 repItems_1=1 nil=2 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: s(active(X)) -> s(X) s(mark(X)) -> s(X) incr(active(X)) -> incr(X) incr(mark(X)) -> incr(X) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) mark(incr(X)) -> active(incr(mark(X))) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) mark(pairNs) -> active(pairNs) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) repItems(active(X)) -> repItems(X) repItems(mark(X)) -> repItems(X) zip(X1, mark(X2)) -> zip(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(active(X)) -> tail(X) tail(mark(X)) -> tail(X) ---------------------------------------- (65) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(incr(cons(X, XS))) -> MARK(cons(s(X), incr(XS))) MARK(cons(X1, X2)) -> ACTIVE(cons(mark(X1), X2)) ACTIVE(take(s(N), cons(X, XS))) -> MARK(cons(X, take(N, XS))) MARK(cons(X1, X2)) -> MARK(X1) MARK(incr(X)) -> ACTIVE(incr(mark(X))) MARK(incr(X)) -> MARK(X) MARK(s(X)) -> ACTIVE(s(mark(X))) MARK(s(X)) -> MARK(X) MARK(take(X1, X2)) -> ACTIVE(take(mark(X1), mark(X2))) MARK(zip(X1, X2)) -> ACTIVE(zip(mark(X1), mark(X2))) MARK(pair(X1, X2)) -> ACTIVE(pair(mark(X1), mark(X2))) MARK(tail(X)) -> ACTIVE(tail(mark(X))) MARK(repItems(X)) -> ACTIVE(repItems(mark(X))) The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (66) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. ACTIVE(take(s(N), cons(X, XS))) -> MARK(cons(X, take(N, XS))) The remaining pairs can at least be oriented weakly. Used ordering: Combined order from the following AFS and order. ACTIVE(x1) = x1 incr(x1) = x1 cons(x1, x2) = x1 MARK(x1) = x1 s(x1) = x1 mark(x1) = x1 take(x1, x2) = take(x2) zip(x1, x2) = zip pair(x1, x2) = pair tail(x1) = tail repItems(x1) = x1 active(x1) = x1 pairNs = pairNs 0 = 0 oddNs = oddNs nil = nil Knuth-Bendix order [KBO] with precedence:oddNs > pairNs > 0 and weight map: oddNs=1 tail=2 zip=3 take_1=1 0=1 pair=2 pairNs=1 nil=2 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: s(active(X)) -> s(X) s(mark(X)) -> s(X) incr(active(X)) -> incr(X) incr(mark(X)) -> incr(X) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) mark(incr(X)) -> active(incr(mark(X))) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) mark(pairNs) -> active(pairNs) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(active(X)) -> tail(X) tail(mark(X)) -> tail(X) repItems(active(X)) -> repItems(X) repItems(mark(X)) -> repItems(X) ---------------------------------------- (67) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(incr(cons(X, XS))) -> MARK(cons(s(X), incr(XS))) MARK(cons(X1, X2)) -> ACTIVE(cons(mark(X1), X2)) MARK(cons(X1, X2)) -> MARK(X1) MARK(incr(X)) -> ACTIVE(incr(mark(X))) MARK(incr(X)) -> MARK(X) MARK(s(X)) -> ACTIVE(s(mark(X))) MARK(s(X)) -> MARK(X) MARK(take(X1, X2)) -> ACTIVE(take(mark(X1), mark(X2))) MARK(zip(X1, X2)) -> ACTIVE(zip(mark(X1), mark(X2))) MARK(pair(X1, X2)) -> ACTIVE(pair(mark(X1), mark(X2))) MARK(tail(X)) -> ACTIVE(tail(mark(X))) MARK(repItems(X)) -> ACTIVE(repItems(mark(X))) The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (68) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MARK(cons(X1, X2)) -> ACTIVE(cons(mark(X1), X2)) MARK(s(X)) -> ACTIVE(s(mark(X))) MARK(take(X1, X2)) -> ACTIVE(take(mark(X1), mark(X2))) MARK(zip(X1, X2)) -> ACTIVE(zip(mark(X1), mark(X2))) MARK(pair(X1, X2)) -> ACTIVE(pair(mark(X1), mark(X2))) MARK(tail(X)) -> ACTIVE(tail(mark(X))) MARK(repItems(X)) -> ACTIVE(repItems(mark(X))) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( ACTIVE_1(x_1) ) = max{0, 2x_1 - 1} POL( MARK_1(x_1) ) = 1 POL( cons_2(x_1, x_2) ) = max{0, -2} POL( s_1(x_1) ) = max{0, -2} POL( active_1(x_1) ) = max{0, -2} POL( mark_1(x_1) ) = 2 POL( incr_1(x_1) ) = 1 POL( pair_2(x_1, x_2) ) = max{0, -2} POL( repItems_1(x_1) ) = max{0, -2} POL( tail_1(x_1) ) = 0 POL( take_2(x_1, x_2) ) = 0 POL( zip_2(x_1, x_2) ) = max{0, -2} POL( pairNs ) = 0 POL( 0 ) = 0 POL( oddNs ) = 0 POL( nil ) = 0 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: s(active(X)) -> s(X) s(mark(X)) -> s(X) incr(active(X)) -> incr(X) incr(mark(X)) -> incr(X) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(active(X)) -> tail(X) tail(mark(X)) -> tail(X) repItems(active(X)) -> repItems(X) repItems(mark(X)) -> repItems(X) ---------------------------------------- (69) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(incr(cons(X, XS))) -> MARK(cons(s(X), incr(XS))) MARK(cons(X1, X2)) -> MARK(X1) MARK(incr(X)) -> ACTIVE(incr(mark(X))) MARK(incr(X)) -> MARK(X) MARK(s(X)) -> MARK(X) The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (70) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MARK(incr(X)) -> ACTIVE(incr(mark(X))) MARK(incr(X)) -> MARK(X) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( MARK_1(x_1) ) = 2x_1 POL( cons_2(x_1, x_2) ) = 2x_1 POL( ACTIVE_1(x_1) ) = max{0, 2x_1 - 2} POL( active_1(x_1) ) = x_1 POL( incr_1(x_1) ) = 2x_1 + 1 POL( mark_1(x_1) ) = x_1 POL( s_1(x_1) ) = 2x_1 POL( pairNs ) = 0 POL( 0 ) = 0 POL( oddNs ) = 1 POL( take_2(x_1, x_2) ) = 2x_1 + x_2 POL( zip_2(x_1, x_2) ) = 2 POL( pair_2(x_1, x_2) ) = max{0, -2} POL( repItems_1(x_1) ) = 2x_1 + 2 POL( tail_1(x_1) ) = max{0, -2} POL( nil ) = 2 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: s(active(X)) -> s(X) s(mark(X)) -> s(X) incr(active(X)) -> incr(X) incr(mark(X)) -> incr(X) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) mark(incr(X)) -> active(incr(mark(X))) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) mark(pairNs) -> active(pairNs) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) repItems(active(X)) -> repItems(X) repItems(mark(X)) -> repItems(X) tail(active(X)) -> tail(X) tail(mark(X)) -> tail(X) ---------------------------------------- (71) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(incr(cons(X, XS))) -> MARK(cons(s(X), incr(XS))) MARK(cons(X1, X2)) -> MARK(X1) MARK(s(X)) -> MARK(X) The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (72) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (73) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(cons(X1, X2)) -> MARK(X1) The TRS R consists of the following rules: active(pairNs) -> mark(cons(0, incr(oddNs))) active(oddNs) -> mark(incr(pairNs)) active(incr(cons(X, XS))) -> mark(cons(s(X), incr(XS))) active(take(s(N), cons(X, XS))) -> mark(cons(X, take(N, XS))) active(zip(cons(X, XS), cons(Y, YS))) -> mark(cons(pair(X, Y), zip(XS, YS))) active(repItems(cons(X, XS))) -> mark(cons(X, cons(X, repItems(XS)))) mark(pairNs) -> active(pairNs) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(incr(X)) -> active(incr(mark(X))) mark(oddNs) -> active(oddNs) mark(s(X)) -> active(s(mark(X))) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(nil) -> active(nil) mark(zip(X1, X2)) -> active(zip(mark(X1), mark(X2))) mark(pair(X1, X2)) -> active(pair(mark(X1), mark(X2))) mark(tail(X)) -> active(tail(mark(X))) mark(repItems(X)) -> active(repItems(mark(X))) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) zip(mark(X1), X2) -> zip(X1, X2) zip(X1, mark(X2)) -> zip(X1, X2) zip(active(X1), X2) -> zip(X1, X2) zip(X1, active(X2)) -> zip(X1, X2) pair(mark(X1), X2) -> pair(X1, X2) pair(X1, mark(X2)) -> pair(X1, X2) pair(active(X1), X2) -> pair(X1, X2) pair(X1, active(X2)) -> pair(X1, X2) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) repItems(mark(X)) -> repItems(X) repItems(active(X)) -> repItems(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (74) UsableRulesProof (EQUIVALENT) We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (75) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(cons(X1, X2)) -> MARK(X1) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (76) QDPSizeChangeProof (EQUIVALENT) By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. From the DPs we obtained the following set of size-change graphs: *MARK(s(X)) -> MARK(X) The graph contains the following edges 1 > 1 *MARK(cons(X1, X2)) -> MARK(X1) The graph contains the following edges 1 > 1 ---------------------------------------- (77) YES