/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, 158 ms] (2) QTRS (3) QTRSRRRProof [EQUIVALENT, 75 ms] (4) QTRS (5) QTRSRRRProof [EQUIVALENT, 36 ms] (6) QTRS (7) DependencyPairsProof [EQUIVALENT, 24 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, 77 ms] (53) QDP (54) QDPOrderProof [EQUIVALENT, 198 ms] (55) QDP (56) QDPOrderProof [EQUIVALENT, 211 ms] (57) QDP (58) QDPOrderProof [EQUIVALENT, 168 ms] (59) QDP (60) QDPOrderProof [EQUIVALENT, 345 ms] (61) QDP (62) QDPOrderProof [EQUIVALENT, 127 ms] (63) QDP (64) QDPOrderProof [EQUIVALENT, 228 ms] (65) QDP (66) QDPOrderProof [EQUIVALENT, 202 ms] (67) QDP (68) QDPOrderProof [EQUIVALENT, 109 ms] (69) QDP (70) QDPOrderProof [EQUIVALENT, 245 ms] (71) QDP (72) QDPOrderProof [EQUIVALENT, 110 ms] (73) QDP (74) QDPOrderProof [EQUIVALENT, 274 ms] (75) QDP (76) QDPOrderProof [EQUIVALENT, 60 ms] (77) QDP (78) TransformationProof [EQUIVALENT, 0 ms] (79) QDP (80) TransformationProof [EQUIVALENT, 0 ms] (81) QDP (82) TransformationProof [EQUIVALENT, 33 ms] (83) QDP (84) DependencyGraphProof [EQUIVALENT, 0 ms] (85) QDP (86) TransformationProof [EQUIVALENT, 0 ms] (87) QDP (88) DependencyGraphProof [EQUIVALENT, 0 ms] (89) QDP (90) TransformationProof [EQUIVALENT, 41 ms] (91) QDP (92) DependencyGraphProof [EQUIVALENT, 0 ms] (93) QDP (94) QDPOrderProof [EQUIVALENT, 303 ms] (95) QDP (96) QDPOrderProof [EQUIVALENT, 275 ms] (97) QDP (98) QDPOrderProof [EQUIVALENT, 170 ms] (99) QDP (100) QDPOrderProof [EQUIVALENT, 255 ms] (101) QDP (102) QDPOrderProof [EQUIVALENT, 211 ms] (103) QDP (104) QDPOrderProof [EQUIVALENT, 504 ms] (105) QDP (106) QDPOrderProof [EQUIVALENT, 443 ms] (107) QDP (108) QDPOrderProof [EQUIVALENT, 381 ms] (109) QDP (110) QDPOrderProof [EQUIVALENT, 927 ms] (111) QDP (112) QDPOrderProof [EQUIVALENT, 653 ms] (113) QDP (114) QDPOrderProof [EQUIVALENT, 367 ms] (115) QDP (116) QDPOrderProof [EQUIVALENT, 668 ms] (117) QDP (118) QDPOrderProof [EQUIVALENT, 522 ms] (119) QDP (120) QDPOrderProof [EQUIVALENT, 189 ms] (121) QDP (122) NonMonReductionPairProof [EQUIVALENT, 4343 ms] (123) QDP (124) QDPOrderProof [EQUIVALENT, 89 ms] (125) QDP (126) PisEmptyProof [EQUIVALENT, 0 ms] (127) YES ---------------------------------------- (0) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(length(V1))) -> mark(isNatList(V1)) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(V)) -> mark(isNatList(V)) active(isNatIList(zeros)) -> mark(tt) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(nil)) -> mark(tt) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(nil)) -> mark(0) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. ---------------------------------------- (1) QTRSRRRProof (EQUIVALENT) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(U11(x_1, x_2)) = x_1 + 2*x_2 POL(active(x_1)) = x_1 POL(and(x_1, x_2)) = 2*x_1 + 2*x_2 POL(cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(isNat(x_1)) = x_1 POL(isNatIList(x_1)) = 2*x_1 POL(isNatList(x_1)) = x_1 POL(length(x_1)) = 2*x_1 POL(mark(x_1)) = x_1 POL(nil) = 1 POL(s(x_1)) = x_1 POL(tt) = 0 POL(zeros) = 0 With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly: active(isNatList(nil)) -> mark(tt) active(length(nil)) -> mark(0) ---------------------------------------- (2) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(length(V1))) -> mark(isNatList(V1)) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(V)) -> mark(isNatList(V)) active(isNatIList(zeros)) -> mark(tt) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. ---------------------------------------- (3) QTRSRRRProof (EQUIVALENT) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(U11(x_1, x_2)) = x_1 + 2*x_2 POL(active(x_1)) = x_1 POL(and(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(isNat(x_1)) = x_1 POL(isNatIList(x_1)) = 1 + x_1 POL(isNatList(x_1)) = x_1 POL(length(x_1)) = 2*x_1 POL(mark(x_1)) = x_1 POL(nil) = 0 POL(s(x_1)) = x_1 POL(tt) = 0 POL(zeros) = 0 With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly: active(isNatIList(V)) -> mark(isNatList(V)) active(isNatIList(zeros)) -> mark(tt) ---------------------------------------- (4) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(length(V1))) -> mark(isNatList(V1)) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. ---------------------------------------- (5) QTRSRRRProof (EQUIVALENT) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(U11(x_1, x_2)) = 2 + x_1 + 2*x_2 POL(active(x_1)) = x_1 POL(and(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(isNat(x_1)) = 2*x_1 POL(isNatIList(x_1)) = x_1 POL(isNatList(x_1)) = x_1 POL(length(x_1)) = 2 + 2*x_1 POL(mark(x_1)) = x_1 POL(nil) = 0 POL(s(x_1)) = x_1 POL(tt) = 0 POL(zeros) = 0 With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly: active(isNat(length(V1))) -> mark(isNatList(V1)) ---------------------------------------- (6) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(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(zeros) -> MARK(cons(0, zeros)) ACTIVE(zeros) -> CONS(0, zeros) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) ACTIVE(U11(tt, L)) -> S(length(L)) ACTIVE(U11(tt, L)) -> LENGTH(L) ACTIVE(and(tt, X)) -> MARK(X) ACTIVE(isNat(0)) -> MARK(tt) ACTIVE(isNat(s(V1))) -> MARK(isNat(V1)) ACTIVE(isNat(s(V1))) -> ISNAT(V1) ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) ACTIVE(isNatIList(cons(V1, V2))) -> AND(isNat(V1), isNatIList(V2)) ACTIVE(isNatIList(cons(V1, V2))) -> ISNAT(V1) ACTIVE(isNatIList(cons(V1, V2))) -> ISNATILIST(V2) ACTIVE(isNatList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatList(V2))) ACTIVE(isNatList(cons(V1, V2))) -> AND(isNat(V1), isNatList(V2)) ACTIVE(isNatList(cons(V1, V2))) -> ISNAT(V1) ACTIVE(isNatList(cons(V1, V2))) -> ISNATLIST(V2) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) ACTIVE(length(cons(N, L))) -> U11^1(and(isNatList(L), isNat(N)), L) ACTIVE(length(cons(N, L))) -> AND(isNatList(L), isNat(N)) ACTIVE(length(cons(N, L))) -> ISNATLIST(L) ACTIVE(length(cons(N, L))) -> ISNAT(N) MARK(zeros) -> ACTIVE(zeros) 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(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) MARK(U11(X1, X2)) -> U11^1(mark(X1), X2) MARK(U11(X1, X2)) -> MARK(X1) MARK(tt) -> ACTIVE(tt) MARK(s(X)) -> ACTIVE(s(mark(X))) MARK(s(X)) -> S(mark(X)) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) MARK(length(X)) -> LENGTH(mark(X)) MARK(length(X)) -> MARK(X) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) MARK(and(X1, X2)) -> AND(mark(X1), X2) MARK(and(X1, X2)) -> MARK(X1) MARK(isNat(X)) -> ACTIVE(isNat(X)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) MARK(nil) -> ACTIVE(nil) 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) U11^1(mark(X1), X2) -> U11^1(X1, X2) U11^1(X1, mark(X2)) -> U11^1(X1, X2) U11^1(active(X1), X2) -> U11^1(X1, X2) U11^1(X1, active(X2)) -> U11^1(X1, X2) S(mark(X)) -> S(X) S(active(X)) -> S(X) LENGTH(mark(X)) -> LENGTH(X) LENGTH(active(X)) -> LENGTH(X) AND(mark(X1), X2) -> AND(X1, X2) AND(X1, mark(X2)) -> AND(X1, X2) AND(active(X1), X2) -> AND(X1, X2) AND(X1, active(X2)) -> AND(X1, X2) ISNAT(mark(X)) -> ISNAT(X) ISNAT(active(X)) -> ISNAT(X) ISNATLIST(mark(X)) -> ISNATLIST(X) ISNATLIST(active(X)) -> ISNATLIST(X) ISNATILIST(mark(X)) -> ISNATILIST(X) ISNATILIST(active(X)) -> ISNATILIST(X) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(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 23 less nodes. ---------------------------------------- (10) Complex Obligation (AND) ---------------------------------------- (11) Obligation: Q DP problem: The TRS P consists of the following rules: ISNATILIST(active(X)) -> ISNATILIST(X) ISNATILIST(mark(X)) -> ISNATILIST(X) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(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: ISNATILIST(active(X)) -> ISNATILIST(X) ISNATILIST(mark(X)) -> ISNATILIST(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: *ISNATILIST(active(X)) -> ISNATILIST(X) The graph contains the following edges 1 > 1 *ISNATILIST(mark(X)) -> ISNATILIST(X) The graph contains the following edges 1 > 1 ---------------------------------------- (15) YES ---------------------------------------- (16) Obligation: Q DP problem: The TRS P consists of the following rules: ISNATLIST(active(X)) -> ISNATLIST(X) ISNATLIST(mark(X)) -> ISNATLIST(X) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(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: ISNATLIST(active(X)) -> ISNATLIST(X) ISNATLIST(mark(X)) -> ISNATLIST(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: *ISNATLIST(active(X)) -> ISNATLIST(X) The graph contains the following edges 1 > 1 *ISNATLIST(mark(X)) -> ISNATLIST(X) The graph contains the following edges 1 > 1 ---------------------------------------- (20) YES ---------------------------------------- (21) Obligation: Q DP problem: The TRS P consists of the following rules: ISNAT(active(X)) -> ISNAT(X) ISNAT(mark(X)) -> ISNAT(X) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(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: ISNAT(active(X)) -> ISNAT(X) ISNAT(mark(X)) -> ISNAT(X) 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: *ISNAT(active(X)) -> ISNAT(X) The graph contains the following edges 1 > 1 *ISNAT(mark(X)) -> ISNAT(X) The graph contains the following edges 1 > 1 ---------------------------------------- (25) YES ---------------------------------------- (26) Obligation: Q DP problem: The TRS P consists of the following rules: AND(X1, mark(X2)) -> AND(X1, X2) AND(mark(X1), X2) -> AND(X1, X2) AND(active(X1), X2) -> AND(X1, X2) AND(X1, active(X2)) -> AND(X1, X2) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(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: AND(X1, mark(X2)) -> AND(X1, X2) AND(mark(X1), X2) -> AND(X1, X2) AND(active(X1), X2) -> AND(X1, X2) AND(X1, active(X2)) -> AND(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: *AND(X1, mark(X2)) -> AND(X1, X2) The graph contains the following edges 1 >= 1, 2 > 2 *AND(mark(X1), X2) -> AND(X1, X2) The graph contains the following edges 1 > 1, 2 >= 2 *AND(active(X1), X2) -> AND(X1, X2) The graph contains the following edges 1 > 1, 2 >= 2 *AND(X1, active(X2)) -> AND(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: LENGTH(active(X)) -> LENGTH(X) LENGTH(mark(X)) -> LENGTH(X) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(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: LENGTH(active(X)) -> LENGTH(X) LENGTH(mark(X)) -> LENGTH(X) 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: *LENGTH(active(X)) -> LENGTH(X) The graph contains the following edges 1 > 1 *LENGTH(mark(X)) -> LENGTH(X) The graph contains the following edges 1 > 1 ---------------------------------------- (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(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(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: U11^1(X1, mark(X2)) -> U11^1(X1, X2) U11^1(mark(X1), X2) -> U11^1(X1, X2) U11^1(active(X1), X2) -> U11^1(X1, X2) U11^1(X1, active(X2)) -> U11^1(X1, X2) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(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: U11^1(X1, mark(X2)) -> U11^1(X1, X2) U11^1(mark(X1), X2) -> U11^1(X1, X2) U11^1(active(X1), X2) -> U11^1(X1, X2) U11^1(X1, active(X2)) -> U11^1(X1, X2) 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: *U11^1(X1, mark(X2)) -> U11^1(X1, X2) The graph contains the following edges 1 >= 1, 2 > 2 *U11^1(mark(X1), X2) -> U11^1(X1, X2) The graph contains the following edges 1 > 1, 2 >= 2 *U11^1(active(X1), X2) -> U11^1(X1, X2) The graph contains the following edges 1 > 1, 2 >= 2 *U11^1(X1, active(X2)) -> U11^1(X1, X2) The graph contains the following edges 1 >= 1, 2 > 2 ---------------------------------------- (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(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(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(U11(tt, L)) -> MARK(s(length(L))) MARK(cons(X1, X2)) -> MARK(X1) MARK(zeros) -> ACTIVE(zeros) ACTIVE(zeros) -> MARK(cons(0, zeros)) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(and(tt, X)) -> MARK(X) MARK(U11(X1, X2)) -> MARK(X1) MARK(s(X)) -> ACTIVE(s(mark(X))) ACTIVE(isNat(s(V1))) -> MARK(isNat(V1)) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) MARK(length(X)) -> MARK(X) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) ACTIVE(isNatList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatList(V2))) MARK(and(X1, X2)) -> MARK(X1) MARK(isNat(X)) -> ACTIVE(isNat(X)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(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(U11(X1, X2)) -> MARK(X1) MARK(length(X)) -> MARK(X) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVE(x_1)) = 2*x_1 POL(MARK(x_1)) = 2*x_1 POL(U11(x_1, x_2)) = 1 + x_1 + 2*x_2 POL(active(x_1)) = x_1 POL(and(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(isNat(x_1)) = 2*x_1 POL(isNatIList(x_1)) = x_1 POL(isNatList(x_1)) = 2*x_1 POL(length(x_1)) = 1 + 2*x_1 POL(mark(x_1)) = x_1 POL(nil) = 0 POL(s(x_1)) = x_1 POL(tt) = 0 POL(zeros) = 0 ---------------------------------------- (53) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(cons(X1, X2)) -> ACTIVE(cons(mark(X1), X2)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(cons(X1, X2)) -> MARK(X1) MARK(zeros) -> ACTIVE(zeros) ACTIVE(zeros) -> MARK(cons(0, zeros)) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(and(tt, X)) -> MARK(X) MARK(s(X)) -> ACTIVE(s(mark(X))) ACTIVE(isNat(s(V1))) -> MARK(isNat(V1)) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) ACTIVE(isNatList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatList(V2))) MARK(and(X1, X2)) -> MARK(X1) MARK(isNat(X)) -> ACTIVE(isNat(X)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (54) 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))) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( ACTIVE_1(x_1) ) = max{0, x_1 - 1} POL( U11_2(x_1, x_2) ) = 2 POL( and_2(x_1, x_2) ) = 2 POL( cons_2(x_1, x_2) ) = max{0, -2} POL( length_1(x_1) ) = 2 POL( s_1(x_1) ) = 0 POL( mark_1(x_1) ) = 0 POL( active_1(x_1) ) = 2 POL( zeros ) = 2 POL( 0 ) = 0 POL( tt ) = 0 POL( isNat_1(x_1) ) = 2 POL( isNatIList_1(x_1) ) = 2 POL( isNatList_1(x_1) ) = 2 POL( nil ) = 0 POL( MARK_1(x_1) ) = 1 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: 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) length(active(X)) -> length(X) length(mark(X)) -> length(X) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) isNat(active(X)) -> isNat(X) isNat(mark(X)) -> isNat(X) isNatIList(active(X)) -> isNatIList(X) isNatIList(mark(X)) -> isNatIList(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNatList(active(X)) -> isNatList(X) isNatList(mark(X)) -> isNatList(X) ---------------------------------------- (55) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(cons(X1, X2)) -> MARK(X1) MARK(zeros) -> ACTIVE(zeros) ACTIVE(zeros) -> MARK(cons(0, zeros)) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(and(tt, X)) -> MARK(X) ACTIVE(isNat(s(V1))) -> MARK(isNat(V1)) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) ACTIVE(isNatList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatList(V2))) MARK(and(X1, X2)) -> MARK(X1) MARK(isNat(X)) -> ACTIVE(isNat(X)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (56) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MARK(zeros) -> ACTIVE(zeros) ACTIVE(zeros) -> MARK(cons(0, zeros)) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( ACTIVE_1(x_1) ) = x_1 + 2 POL( MARK_1(x_1) ) = 2x_1 + 2 POL( s_1(x_1) ) = 2x_1 POL( length_1(x_1) ) = max{0, -2} POL( active_1(x_1) ) = x_1 POL( mark_1(x_1) ) = 2x_1 POL( U11_2(x_1, x_2) ) = max{0, -2} POL( and_2(x_1, x_2) ) = x_1 + 2x_2 POL( cons_2(x_1, x_2) ) = 2x_1 POL( zeros ) = 2 POL( 0 ) = 0 POL( tt ) = 0 POL( isNat_1(x_1) ) = 0 POL( isNatIList_1(x_1) ) = 0 POL( isNatList_1(x_1) ) = 0 POL( nil ) = 2 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: length(active(X)) -> length(X) length(mark(X)) -> length(X) s(active(X)) -> s(X) s(mark(X)) -> s(X) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(and(tt, X)) -> mark(X) mark(s(X)) -> active(s(mark(X))) active(isNat(s(V1))) -> mark(isNat(V1)) mark(length(X)) -> active(length(mark(X))) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) mark(isNat(X)) -> active(isNat(X)) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) mark(nil) -> active(nil) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) isNat(active(X)) -> isNat(X) isNat(mark(X)) -> isNat(X) isNatIList(active(X)) -> isNatIList(X) isNatIList(mark(X)) -> isNatIList(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNatList(active(X)) -> isNatList(X) isNatList(mark(X)) -> isNatList(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) active(isNat(0)) -> mark(tt) ---------------------------------------- (57) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(cons(X1, X2)) -> MARK(X1) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(and(tt, X)) -> MARK(X) ACTIVE(isNat(s(V1))) -> MARK(isNat(V1)) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) ACTIVE(isNatList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatList(V2))) MARK(and(X1, X2)) -> MARK(X1) MARK(isNat(X)) -> ACTIVE(isNat(X)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (58) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MARK(cons(X1, X2)) -> MARK(X1) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( ACTIVE_1(x_1) ) = x_1 POL( MARK_1(x_1) ) = x_1 POL( s_1(x_1) ) = x_1 POL( length_1(x_1) ) = 2 POL( active_1(x_1) ) = x_1 POL( mark_1(x_1) ) = x_1 POL( U11_2(x_1, x_2) ) = 2 POL( and_2(x_1, x_2) ) = x_1 + x_2 POL( cons_2(x_1, x_2) ) = x_1 + 2 POL( zeros ) = 2 POL( 0 ) = 0 POL( tt ) = 0 POL( isNat_1(x_1) ) = 0 POL( isNatIList_1(x_1) ) = 0 POL( isNatList_1(x_1) ) = 0 POL( nil ) = 0 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: length(active(X)) -> length(X) length(mark(X)) -> length(X) s(active(X)) -> s(X) s(mark(X)) -> s(X) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(and(tt, X)) -> mark(X) mark(s(X)) -> active(s(mark(X))) active(isNat(s(V1))) -> mark(isNat(V1)) mark(length(X)) -> active(length(mark(X))) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) mark(isNat(X)) -> active(isNat(X)) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) mark(nil) -> active(nil) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) isNat(active(X)) -> isNat(X) isNat(mark(X)) -> isNat(X) isNatIList(active(X)) -> isNatIList(X) isNatIList(mark(X)) -> isNatIList(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNatList(active(X)) -> isNatList(X) isNatList(mark(X)) -> isNatList(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) active(isNat(0)) -> mark(tt) ---------------------------------------- (59) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(and(tt, X)) -> MARK(X) ACTIVE(isNat(s(V1))) -> MARK(isNat(V1)) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) ACTIVE(isNatList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatList(V2))) MARK(and(X1, X2)) -> MARK(X1) MARK(isNat(X)) -> ACTIVE(isNat(X)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(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. MARK(and(X1, X2)) -> MARK(X1) The remaining pairs can at least be oriented weakly. Used ordering: Matrix interpretation [MATRO] with arctic natural numbers [ARCTIC]: <<< POL(ACTIVE(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(U11(x_1, x_2)) = [[-I]] + [[-I]] * x_1 + [[0A]] * x_2 >>> <<< POL(tt) = [[0A]] >>> <<< POL(MARK(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(s(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(length(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(mark(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(and(x_1, x_2)) = [[-I]] + [[1A]] * x_1 + [[0A]] * x_2 >>> <<< POL(isNat(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(isNatIList(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(cons(x_1, x_2)) = [[-I]] + [[1A]] * x_1 + [[0A]] * x_2 >>> <<< POL(isNatList(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(active(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(zeros) = [[1A]] >>> <<< POL(0) = [[0A]] >>> <<< POL(nil) = [[0A]] >>> The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: length(active(X)) -> length(X) length(mark(X)) -> length(X) s(active(X)) -> s(X) s(mark(X)) -> s(X) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(and(tt, X)) -> mark(X) mark(s(X)) -> active(s(mark(X))) active(isNat(s(V1))) -> mark(isNat(V1)) mark(length(X)) -> active(length(mark(X))) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) mark(isNat(X)) -> active(isNat(X)) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) mark(nil) -> active(nil) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) isNat(active(X)) -> isNat(X) isNat(mark(X)) -> isNat(X) isNatIList(active(X)) -> isNatIList(X) isNatIList(mark(X)) -> isNatIList(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNatList(active(X)) -> isNatList(X) isNatList(mark(X)) -> isNatList(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) active(isNat(0)) -> mark(tt) ---------------------------------------- (61) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(and(tt, X)) -> MARK(X) ACTIVE(isNat(s(V1))) -> MARK(isNat(V1)) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) ACTIVE(isNatList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatList(V2))) MARK(isNat(X)) -> ACTIVE(isNat(X)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (62) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. ACTIVE(isNat(s(V1))) -> MARK(isNat(V1)) 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 - 2} POL( MARK_1(x_1) ) = max{0, 2x_1 - 2} POL( s_1(x_1) ) = x_1 + 1 POL( length_1(x_1) ) = max{0, -2} POL( active_1(x_1) ) = x_1 POL( mark_1(x_1) ) = x_1 + 2 POL( U11_2(x_1, x_2) ) = max{0, -2} POL( and_2(x_1, x_2) ) = x_2 + 1 POL( cons_2(x_1, x_2) ) = max{0, -2} POL( zeros ) = 1 POL( 0 ) = 0 POL( tt ) = 0 POL( isNat_1(x_1) ) = 2x_1 + 1 POL( isNatIList_1(x_1) ) = 0 POL( isNatList_1(x_1) ) = 0 POL( nil ) = 2 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: length(active(X)) -> length(X) length(mark(X)) -> length(X) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) isNat(active(X)) -> isNat(X) isNat(mark(X)) -> isNat(X) isNatIList(active(X)) -> isNatIList(X) isNatIList(mark(X)) -> isNatIList(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNatList(active(X)) -> isNatList(X) isNatList(mark(X)) -> isNatList(X) ---------------------------------------- (63) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(and(tt, X)) -> MARK(X) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) ACTIVE(isNatList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatList(V2))) MARK(isNat(X)) -> ACTIVE(isNat(X)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(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. MARK(isNat(X)) -> ACTIVE(isNat(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 - 2} POL( MARK_1(x_1) ) = 2 POL( s_1(x_1) ) = max{0, -2} POL( length_1(x_1) ) = 2 POL( active_1(x_1) ) = max{0, -2} POL( mark_1(x_1) ) = max{0, -2} POL( U11_2(x_1, x_2) ) = 2 POL( and_2(x_1, x_2) ) = 2 POL( cons_2(x_1, x_2) ) = max{0, x_1 - 2} POL( zeros ) = 0 POL( 0 ) = 0 POL( tt ) = 0 POL( isNat_1(x_1) ) = 0 POL( isNatIList_1(x_1) ) = 2 POL( isNatList_1(x_1) ) = 2 POL( nil ) = 0 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: length(active(X)) -> length(X) length(mark(X)) -> length(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) isNat(active(X)) -> isNat(X) isNat(mark(X)) -> isNat(X) isNatIList(active(X)) -> isNatIList(X) isNatIList(mark(X)) -> isNatIList(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNatList(active(X)) -> isNatList(X) isNatList(mark(X)) -> isNatList(X) ---------------------------------------- (65) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(and(tt, X)) -> MARK(X) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) ACTIVE(isNatList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatList(V2))) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(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(isNatList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatList(V2))) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( ACTIVE_1(x_1) ) = max{0, x_1 - 2} POL( MARK_1(x_1) ) = max{0, x_1 - 2} POL( s_1(x_1) ) = x_1 + 2 POL( length_1(x_1) ) = max{0, -2} POL( active_1(x_1) ) = x_1 + 2 POL( mark_1(x_1) ) = 2x_1 + 2 POL( U11_2(x_1, x_2) ) = max{0, -2} POL( and_2(x_1, x_2) ) = x_2 + 2 POL( cons_2(x_1, x_2) ) = x_2 + 2 POL( zeros ) = 2 POL( 0 ) = 0 POL( tt ) = 0 POL( isNat_1(x_1) ) = 0 POL( isNatIList_1(x_1) ) = 0 POL( isNatList_1(x_1) ) = 2x_1 + 2 POL( nil ) = 0 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: length(active(X)) -> length(X) length(mark(X)) -> length(X) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) isNatIList(active(X)) -> isNatIList(X) isNatIList(mark(X)) -> isNatIList(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNatList(active(X)) -> isNatList(X) isNatList(mark(X)) -> isNatList(X) ---------------------------------------- (67) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(and(tt, X)) -> MARK(X) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(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(isNatList(X)) -> ACTIVE(isNatList(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( s_1(x_1) ) = max{0, x_1 - 2} POL( length_1(x_1) ) = 1 POL( active_1(x_1) ) = max{0, -2} POL( mark_1(x_1) ) = 2x_1 + 2 POL( U11_2(x_1, x_2) ) = 1 POL( and_2(x_1, x_2) ) = 1 POL( cons_2(x_1, x_2) ) = max{0, 2x_1 - 2} POL( zeros ) = 0 POL( 0 ) = 0 POL( tt ) = 0 POL( isNat_1(x_1) ) = 0 POL( isNatIList_1(x_1) ) = 1 POL( isNatList_1(x_1) ) = 0 POL( nil ) = 0 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: length(active(X)) -> length(X) length(mark(X)) -> length(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) isNatIList(active(X)) -> isNatIList(X) isNatIList(mark(X)) -> isNatIList(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNatList(active(X)) -> isNatList(X) isNatList(mark(X)) -> isNatList(X) ---------------------------------------- (69) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(and(tt, X)) -> MARK(X) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(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. ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) The remaining pairs can at least be oriented weakly. Used ordering: Combined order from the following AFS and order. ACTIVE(x1) = ACTIVE(x1) U11(x1, x2) = U11 tt = tt MARK(x1) = MARK(x1) s(x1) = x1 length(x1) = length mark(x1) = mark(x1) and(x1, x2) = x2 isNatIList(x1) = isNatIList(x1) cons(x1, x2) = cons(x2) isNat(x1) = isNat(x1) isNatList(x1) = x1 active(x1) = x1 zeros = zeros 0 = 0 nil = nil Recursive path order with status [RPO]. Quasi-Precedence: [U11, length] > [ACTIVE_1, MARK_1] > isNatIList_1 > cons_1 [U11, length] > isNat_1 > [mark_1, nil] > tt > cons_1 [U11, length] > isNat_1 > [mark_1, nil] > isNatIList_1 > cons_1 [U11, length] > isNat_1 > [mark_1, nil] > zeros > cons_1 0 > [mark_1, nil] > tt > cons_1 0 > [mark_1, nil] > isNatIList_1 > cons_1 0 > [mark_1, nil] > zeros > cons_1 Status: ACTIVE_1: multiset status U11: multiset status tt: multiset status MARK_1: multiset status length: multiset status mark_1: [1] isNatIList_1: [1] cons_1: [1] isNat_1: multiset status zeros: multiset status 0: multiset status nil: multiset status The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: length(active(X)) -> length(X) length(mark(X)) -> length(X) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) isNatIList(active(X)) -> isNatIList(X) isNatIList(mark(X)) -> isNatIList(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) ---------------------------------------- (71) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(and(tt, X)) -> MARK(X) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (72) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MARK(isNatIList(X)) -> ACTIVE(isNatIList(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, x_1 - 1} POL( MARK_1(x_1) ) = 1 POL( s_1(x_1) ) = 0 POL( length_1(x_1) ) = 2 POL( active_1(x_1) ) = max{0, -2} POL( mark_1(x_1) ) = 2x_1 + 2 POL( U11_2(x_1, x_2) ) = 2 POL( and_2(x_1, x_2) ) = 2 POL( cons_2(x_1, x_2) ) = max{0, x_2 - 2} POL( zeros ) = 0 POL( 0 ) = 2 POL( tt ) = 0 POL( isNat_1(x_1) ) = 0 POL( isNatIList_1(x_1) ) = 0 POL( isNatList_1(x_1) ) = 2 POL( nil ) = 0 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: length(active(X)) -> length(X) length(mark(X)) -> length(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNatIList(active(X)) -> isNatIList(X) isNatIList(mark(X)) -> isNatIList(X) ---------------------------------------- (73) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(and(tt, X)) -> MARK(X) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (74) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. ACTIVE(and(tt, X)) -> MARK(X) The remaining pairs can at least be oriented weakly. Used ordering: Combined order from the following AFS and order. ACTIVE(x1) = ACTIVE(x1) U11(x1, x2) = U11 tt = tt MARK(x1) = MARK(x1) s(x1) = x1 length(x1) = length mark(x1) = x1 and(x1, x2) = and(x2) cons(x1, x2) = x1 isNatList(x1) = isNatList(x1) isNat(x1) = isNat active(x1) = x1 zeros = zeros 0 = 0 isNatIList(x1) = isNatIList nil = nil Recursive path order with status [RPO]. Quasi-Precedence: [ACTIVE_1, MARK_1, and_1] > [U11, length] > isNatList_1 > isNat zeros > isNat 0 > tt > isNat isNatIList > isNat nil > isNat Status: ACTIVE_1: multiset status U11: multiset status tt: multiset status MARK_1: multiset status length: multiset status and_1: [1] isNatList_1: multiset status isNat: multiset status zeros: multiset status 0: multiset status isNatIList: multiset status nil: multiset status The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: length(active(X)) -> length(X) length(mark(X)) -> length(X) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) ---------------------------------------- (75) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (76) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) 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( s_1(x_1) ) = max{0, -2} POL( length_1(x_1) ) = 1 POL( active_1(x_1) ) = max{0, -2} POL( mark_1(x_1) ) = 0 POL( U11_2(x_1, x_2) ) = 1 POL( and_2(x_1, x_2) ) = max{0, -2} POL( cons_2(x_1, x_2) ) = 2 POL( zeros ) = 0 POL( 0 ) = 0 POL( tt ) = 0 POL( isNat_1(x_1) ) = 0 POL( isNatIList_1(x_1) ) = 0 POL( isNatList_1(x_1) ) = 0 POL( nil ) = 0 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: length(active(X)) -> length(X) length(mark(X)) -> length(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) ---------------------------------------- (77) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (78) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) at position [0] we obtained the following new rules [LPAR04]: (MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)),MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1))) (MARK(U11(y0, mark(x1))) -> ACTIVE(U11(mark(y0), x1)),MARK(U11(y0, mark(x1))) -> ACTIVE(U11(mark(y0), x1))) (MARK(U11(y0, active(x1))) -> ACTIVE(U11(mark(y0), x1)),MARK(U11(y0, active(x1))) -> ACTIVE(U11(mark(y0), x1))) (MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)),MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1))) (MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)),MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1))) (MARK(U11(0, y1)) -> ACTIVE(U11(active(0), y1)),MARK(U11(0, y1)) -> ACTIVE(U11(active(0), y1))) (MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1)),MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1))) (MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1)),MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1))) (MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1)),MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1))) (MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)),MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1))) (MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)),MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1))) (MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1)),MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1))) (MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)),MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1))) (MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1)),MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1))) (MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)),MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1))) ---------------------------------------- (79) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) MARK(U11(y0, mark(x1))) -> ACTIVE(U11(mark(y0), x1)) MARK(U11(y0, active(x1))) -> ACTIVE(U11(mark(y0), x1)) MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)) MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)) MARK(U11(0, y1)) -> ACTIVE(U11(active(0), y1)) MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1)) MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1)) MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1)) MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)) MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1)) MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (80) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule MARK(length(X)) -> ACTIVE(length(mark(X))) at position [0] we obtained the following new rules [LPAR04]: (MARK(length(x0)) -> ACTIVE(length(x0)),MARK(length(x0)) -> ACTIVE(length(x0))) (MARK(length(zeros)) -> ACTIVE(length(active(zeros))),MARK(length(zeros)) -> ACTIVE(length(active(zeros)))) (MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))),MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1))))) (MARK(length(0)) -> ACTIVE(length(active(0))),MARK(length(0)) -> ACTIVE(length(active(0)))) (MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))),MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1))))) (MARK(length(tt)) -> ACTIVE(length(active(tt))),MARK(length(tt)) -> ACTIVE(length(active(tt)))) (MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))),MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0)))))) (MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))),MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0)))))) (MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))),MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1))))) (MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))),MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0))))) (MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))),MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0))))) (MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))),MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0))))) (MARK(length(nil)) -> ACTIVE(length(active(nil))),MARK(length(nil)) -> ACTIVE(length(active(nil)))) ---------------------------------------- (81) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(s(X)) -> MARK(X) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) MARK(U11(y0, mark(x1))) -> ACTIVE(U11(mark(y0), x1)) MARK(U11(y0, active(x1))) -> ACTIVE(U11(mark(y0), x1)) MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)) MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)) MARK(U11(0, y1)) -> ACTIVE(U11(active(0), y1)) MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1)) MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1)) MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1)) MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)) MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1)) MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(0)) -> ACTIVE(length(active(0))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(tt)) -> ACTIVE(length(active(tt))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(length(nil)) -> ACTIVE(length(active(nil))) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (82) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule MARK(length(0)) -> ACTIVE(length(active(0))) at position [0] we obtained the following new rules [LPAR04]: (MARK(length(0)) -> ACTIVE(length(0)),MARK(length(0)) -> ACTIVE(length(0))) ---------------------------------------- (83) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(s(X)) -> MARK(X) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) MARK(U11(y0, mark(x1))) -> ACTIVE(U11(mark(y0), x1)) MARK(U11(y0, active(x1))) -> ACTIVE(U11(mark(y0), x1)) MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)) MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)) MARK(U11(0, y1)) -> ACTIVE(U11(active(0), y1)) MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1)) MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1)) MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1)) MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)) MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1)) MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(tt)) -> ACTIVE(length(active(tt))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(length(nil)) -> ACTIVE(length(active(nil))) MARK(length(0)) -> ACTIVE(length(0)) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (84) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (85) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(y0, mark(x1))) -> ACTIVE(U11(mark(y0), x1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(y0, active(x1))) -> ACTIVE(U11(mark(y0), x1)) MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)) MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)) MARK(U11(0, y1)) -> ACTIVE(U11(active(0), y1)) MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1)) MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1)) MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1)) MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)) MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1)) MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(tt)) -> ACTIVE(length(active(tt))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(length(nil)) -> ACTIVE(length(active(nil))) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (86) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule MARK(length(tt)) -> ACTIVE(length(active(tt))) at position [0] we obtained the following new rules [LPAR04]: (MARK(length(tt)) -> ACTIVE(length(tt)),MARK(length(tt)) -> ACTIVE(length(tt))) ---------------------------------------- (87) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(y0, mark(x1))) -> ACTIVE(U11(mark(y0), x1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(y0, active(x1))) -> ACTIVE(U11(mark(y0), x1)) MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)) MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)) MARK(U11(0, y1)) -> ACTIVE(U11(active(0), y1)) MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1)) MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1)) MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1)) MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)) MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1)) MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(length(nil)) -> ACTIVE(length(active(nil))) MARK(length(tt)) -> ACTIVE(length(tt)) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (88) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (89) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(y0, mark(x1))) -> ACTIVE(U11(mark(y0), x1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(y0, active(x1))) -> ACTIVE(U11(mark(y0), x1)) MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)) MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)) MARK(U11(0, y1)) -> ACTIVE(U11(active(0), y1)) MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1)) MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1)) MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1)) MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)) MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1)) MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(length(nil)) -> ACTIVE(length(active(nil))) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (90) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule MARK(length(nil)) -> ACTIVE(length(active(nil))) at position [0] we obtained the following new rules [LPAR04]: (MARK(length(nil)) -> ACTIVE(length(nil)),MARK(length(nil)) -> ACTIVE(length(nil))) ---------------------------------------- (91) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(y0, mark(x1))) -> ACTIVE(U11(mark(y0), x1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(y0, active(x1))) -> ACTIVE(U11(mark(y0), x1)) MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)) MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)) MARK(U11(0, y1)) -> ACTIVE(U11(active(0), y1)) MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1)) MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1)) MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1)) MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)) MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1)) MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(length(nil)) -> ACTIVE(length(nil)) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (92) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (93) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(y0, mark(x1))) -> ACTIVE(U11(mark(y0), x1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(y0, active(x1))) -> ACTIVE(U11(mark(y0), x1)) MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)) MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)) MARK(U11(0, y1)) -> ACTIVE(U11(active(0), y1)) MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1)) MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1)) MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1)) MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)) MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1)) MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (94) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1)) MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1)) MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1)) MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1)) MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1)) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( ACTIVE_1(x_1) ) = max{0, -2} POL( MARK_1(x_1) ) = max{0, 2x_1 - 2} POL( U11_2(x_1, x_2) ) = 2x_1 + 1 POL( mark_1(x_1) ) = x_1 POL( active_1(x_1) ) = 2x_1 POL( s_1(x_1) ) = 2x_1 + 1 POL( length_1(x_1) ) = 0 POL( cons_2(x_1, x_2) ) = max{0, -2} POL( zeros ) = 0 POL( 0 ) = 0 POL( tt ) = 1 POL( and_2(x_1, x_2) ) = max{0, -2} POL( isNat_1(x_1) ) = 1 POL( isNatIList_1(x_1) ) = 1 POL( isNatList_1(x_1) ) = 0 POL( nil ) = 0 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) s(active(X)) -> s(X) s(mark(X)) -> s(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) ---------------------------------------- (95) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(y0, mark(x1))) -> ACTIVE(U11(mark(y0), x1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(y0, active(x1))) -> ACTIVE(U11(mark(y0), x1)) MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)) MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)) MARK(U11(0, y1)) -> ACTIVE(U11(active(0), y1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)) MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (96) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)) MARK(U11(0, y1)) -> ACTIVE(U11(active(0), y1)) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( ACTIVE_1(x_1) ) = max{0, -2} POL( MARK_1(x_1) ) = max{0, 2x_1 - 2} POL( U11_2(x_1, x_2) ) = 2x_1 + 1 POL( mark_1(x_1) ) = x_1 POL( active_1(x_1) ) = 2x_1 + 2 POL( s_1(x_1) ) = 2x_1 + 1 POL( length_1(x_1) ) = max{0, -2} POL( cons_2(x_1, x_2) ) = 1 POL( zeros ) = 0 POL( 0 ) = 1 POL( tt ) = 0 POL( and_2(x_1, x_2) ) = max{0, -2} POL( isNat_1(x_1) ) = x_1 + 2 POL( isNatIList_1(x_1) ) = 2 POL( isNatList_1(x_1) ) = 0 POL( nil ) = 0 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) s(active(X)) -> s(X) s(mark(X)) -> s(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) ---------------------------------------- (97) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(y0, mark(x1))) -> ACTIVE(U11(mark(y0), x1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(y0, active(x1))) -> ACTIVE(U11(mark(y0), x1)) MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)) MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (98) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)) MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( ACTIVE_1(x_1) ) = max{0, -2} POL( MARK_1(x_1) ) = max{0, x_1 - 2} POL( U11_2(x_1, x_2) ) = 2x_1 + 2 POL( mark_1(x_1) ) = 2x_1 POL( active_1(x_1) ) = x_1 + 2 POL( s_1(x_1) ) = 2x_1 + 2 POL( length_1(x_1) ) = max{0, -2} POL( cons_2(x_1, x_2) ) = x_2 + 2 POL( zeros ) = 1 POL( 0 ) = 0 POL( tt ) = 2 POL( and_2(x_1, x_2) ) = max{0, -2} POL( isNat_1(x_1) ) = 2x_1 POL( isNatIList_1(x_1) ) = x_1 + 2 POL( isNatList_1(x_1) ) = 2 POL( nil ) = 0 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) s(active(X)) -> s(X) s(mark(X)) -> s(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) ---------------------------------------- (99) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(y0, mark(x1))) -> ACTIVE(U11(mark(y0), x1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(y0, active(x1))) -> ACTIVE(U11(mark(y0), x1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (100) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( ACTIVE_1(x_1) ) = max{0, -2} POL( MARK_1(x_1) ) = max{0, 2x_1 - 2} POL( U11_2(x_1, x_2) ) = 2x_1 + 1 POL( mark_1(x_1) ) = 2x_1 POL( active_1(x_1) ) = 2x_1 POL( s_1(x_1) ) = x_1 + 1 POL( length_1(x_1) ) = max{0, -2} POL( cons_2(x_1, x_2) ) = max{0, 2x_1 - 2} POL( zeros ) = 0 POL( 0 ) = 0 POL( tt ) = 0 POL( and_2(x_1, x_2) ) = max{0, -2} POL( isNat_1(x_1) ) = 0 POL( isNatIList_1(x_1) ) = 0 POL( isNatList_1(x_1) ) = 0 POL( nil ) = 1 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) s(active(X)) -> s(X) s(mark(X)) -> s(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) ---------------------------------------- (101) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(y0, mark(x1))) -> ACTIVE(U11(mark(y0), x1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(y0, active(x1))) -> ACTIVE(U11(mark(y0), x1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (102) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( ACTIVE_1(x_1) ) = 2 POL( MARK_1(x_1) ) = x_1 POL( U11_2(x_1, x_2) ) = 2x_1 + 2 POL( mark_1(x_1) ) = x_1 POL( active_1(x_1) ) = 2x_1 + 2 POL( s_1(x_1) ) = x_1 POL( length_1(x_1) ) = 2 POL( cons_2(x_1, x_2) ) = max{0, 2x_1 - 2} POL( zeros ) = 0 POL( 0 ) = 2 POL( tt ) = 0 POL( and_2(x_1, x_2) ) = max{0, -2} POL( isNat_1(x_1) ) = x_1 + 2 POL( isNatIList_1(x_1) ) = 2x_1 POL( isNatList_1(x_1) ) = 0 POL( nil ) = 2 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) s(active(X)) -> s(X) s(mark(X)) -> s(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) ---------------------------------------- (103) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(y0, mark(x1))) -> ACTIVE(U11(mark(y0), x1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(y0, active(x1))) -> ACTIVE(U11(mark(y0), x1)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (104) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) The remaining pairs can at least be oriented weakly. Used ordering: Matrix interpretation [MATRO] with arctic natural numbers [ARCTIC]: <<< POL(MARK(x_1)) = [[1A]] + [[0A]] * x_1 >>> <<< POL(s(x_1)) = [[0A]] + [[0A]] * x_1 >>> <<< POL(U11(x_1, x_2)) = [[-I]] + [[1A]] * x_1 + [[0A]] * x_2 >>> <<< POL(ACTIVE(x_1)) = [[0A]] + [[0A]] * x_1 >>> <<< POL(tt) = [[0A]] >>> <<< POL(length(x_1)) = [[0A]] + [[0A]] * x_1 >>> <<< POL(mark(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(cons(x_1, x_2)) = [[1A]] + [[-I]] * x_1 + [[0A]] * x_2 >>> <<< POL(and(x_1, x_2)) = [[0A]] + [[-I]] * x_1 + [[0A]] * x_2 >>> <<< POL(isNatList(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(isNat(x_1)) = [[0A]] + [[-I]] * x_1 >>> <<< POL(active(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(zeros) = [[1A]] >>> <<< POL(isNatIList(x_1)) = [[0A]] + [[0A]] * x_1 >>> <<< POL(0) = [[0A]] >>> <<< POL(nil) = [[0A]] >>> The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) s(active(X)) -> s(X) s(mark(X)) -> s(X) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(and(tt, X)) -> mark(X) mark(s(X)) -> active(s(mark(X))) active(isNat(s(V1))) -> mark(isNat(V1)) mark(length(X)) -> active(length(mark(X))) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) mark(isNat(X)) -> active(isNat(X)) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) mark(nil) -> active(nil) isNatList(active(X)) -> isNatList(X) isNatList(mark(X)) -> isNatList(X) isNat(active(X)) -> isNat(X) isNat(mark(X)) -> isNat(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) active(isNat(0)) -> mark(tt) 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) isNatIList(active(X)) -> isNatIList(X) isNatIList(mark(X)) -> isNatIList(X) ---------------------------------------- (105) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(y0, mark(x1))) -> ACTIVE(U11(mark(y0), x1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(y0, active(x1))) -> ACTIVE(U11(mark(y0), x1)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (106) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) The remaining pairs can at least be oriented weakly. Used ordering: Matrix interpretation [MATRO] with arctic natural numbers [ARCTIC]: <<< POL(MARK(x_1)) = [[1A]] + [[0A]] * x_1 >>> <<< POL(s(x_1)) = [[0A]] + [[0A]] * x_1 >>> <<< POL(U11(x_1, x_2)) = [[0A]] + [[1A]] * x_1 + [[0A]] * x_2 >>> <<< POL(ACTIVE(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(tt) = [[0A]] >>> <<< POL(length(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(mark(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(cons(x_1, x_2)) = [[1A]] + [[0A]] * x_1 + [[0A]] * x_2 >>> <<< POL(and(x_1, x_2)) = [[-I]] + [[0A]] * x_1 + [[0A]] * x_2 >>> <<< POL(isNatList(x_1)) = [[0A]] + [[-I]] * x_1 >>> <<< POL(isNat(x_1)) = [[0A]] + [[-I]] * x_1 >>> <<< POL(active(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(zeros) = [[1A]] >>> <<< POL(isNatIList(x_1)) = [[1A]] + [[-I]] * x_1 >>> <<< POL(0) = [[0A]] >>> <<< POL(nil) = [[0A]] >>> The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) s(active(X)) -> s(X) s(mark(X)) -> s(X) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(and(tt, X)) -> mark(X) mark(s(X)) -> active(s(mark(X))) active(isNat(s(V1))) -> mark(isNat(V1)) mark(length(X)) -> active(length(mark(X))) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) mark(isNat(X)) -> active(isNat(X)) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) mark(nil) -> active(nil) isNatList(active(X)) -> isNatList(X) isNatList(mark(X)) -> isNatList(X) isNat(active(X)) -> isNat(X) isNat(mark(X)) -> isNat(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) active(isNat(0)) -> mark(tt) 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) isNatIList(active(X)) -> isNatIList(X) isNatIList(mark(X)) -> isNatIList(X) ---------------------------------------- (107) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(y0, mark(x1))) -> ACTIVE(U11(mark(y0), x1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(y0, active(x1))) -> ACTIVE(U11(mark(y0), x1)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (108) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) The remaining pairs can at least be oriented weakly. Used ordering: Matrix interpretation [MATRO] with arctic natural numbers [ARCTIC]: <<< POL(MARK(x_1)) = [[1A]] + [[0A]] * x_1 >>> <<< POL(s(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(U11(x_1, x_2)) = [[1A]] + [[-I]] * x_1 + [[0A]] * x_2 >>> <<< POL(ACTIVE(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(tt) = [[0A]] >>> <<< POL(length(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(mark(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(cons(x_1, x_2)) = [[1A]] + [[0A]] * x_1 + [[0A]] * x_2 >>> <<< POL(and(x_1, x_2)) = [[-I]] + [[-I]] * x_1 + [[0A]] * x_2 >>> <<< POL(isNatList(x_1)) = [[0A]] + [[-I]] * x_1 >>> <<< POL(isNat(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(active(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(zeros) = [[1A]] >>> <<< POL(isNatIList(x_1)) = [[0A]] + [[-I]] * x_1 >>> <<< POL(0) = [[0A]] >>> <<< POL(nil) = [[0A]] >>> The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) s(active(X)) -> s(X) s(mark(X)) -> s(X) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(and(tt, X)) -> mark(X) mark(s(X)) -> active(s(mark(X))) active(isNat(s(V1))) -> mark(isNat(V1)) mark(length(X)) -> active(length(mark(X))) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) mark(isNat(X)) -> active(isNat(X)) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) mark(nil) -> active(nil) isNatList(active(X)) -> isNatList(X) isNatList(mark(X)) -> isNatList(X) isNat(active(X)) -> isNat(X) isNat(mark(X)) -> isNat(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) active(isNat(0)) -> mark(tt) 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) isNatIList(active(X)) -> isNatIList(X) isNatIList(mark(X)) -> isNatIList(X) ---------------------------------------- (109) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(y0, mark(x1))) -> ACTIVE(U11(mark(y0), x1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(y0, active(x1))) -> ACTIVE(U11(mark(y0), x1)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (110) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MARK(U11(y0, mark(x1))) -> ACTIVE(U11(mark(y0), x1)) MARK(U11(y0, active(x1))) -> ACTIVE(U11(mark(y0), x1)) The remaining pairs can at least be oriented weakly. Used ordering: Matrix interpretation [MATRO] with arctic natural numbers [ARCTIC]: <<< POL(MARK(x_1)) = [[0A]] + [[1A]] * x_1 >>> <<< POL(s(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(U11(x_1, x_2)) = [[1A]] + [[-I]] * x_1 + [[1A]] * x_2 >>> <<< POL(ACTIVE(x_1)) = [[2A]] + [[0A]] * x_1 >>> <<< POL(tt) = [[0A]] >>> <<< POL(length(x_1)) = [[1A]] + [[0A]] * x_1 >>> <<< POL(mark(x_1)) = [[2A]] + [[0A]] * x_1 >>> <<< POL(cons(x_1, x_2)) = [[-I]] + [[0A]] * x_1 + [[2A]] * x_2 >>> <<< POL(and(x_1, x_2)) = [[-I]] + [[-I]] * x_1 + [[0A]] * x_2 >>> <<< POL(isNatList(x_1)) = [[0A]] + [[0A]] * x_1 >>> <<< POL(isNat(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(active(x_1)) = [[2A]] + [[0A]] * x_1 >>> <<< POL(zeros) = [[0A]] >>> <<< POL(0) = [[0A]] >>> <<< POL(isNatIList(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(nil) = [[0A]] >>> The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) s(active(X)) -> s(X) s(mark(X)) -> s(X) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(and(tt, X)) -> mark(X) mark(s(X)) -> active(s(mark(X))) active(isNat(s(V1))) -> mark(isNat(V1)) mark(length(X)) -> active(length(mark(X))) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) mark(isNat(X)) -> active(isNat(X)) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) mark(nil) -> active(nil) isNatList(active(X)) -> isNatList(X) isNatList(mark(X)) -> isNatList(X) isNat(active(X)) -> isNat(X) isNat(mark(X)) -> isNat(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) active(isNat(0)) -> mark(tt) 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) isNatIList(active(X)) -> isNatIList(X) isNatIList(mark(X)) -> isNatIList(X) ---------------------------------------- (111) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (112) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) The remaining pairs can at least be oriented weakly. Used ordering: Matrix interpretation [MATRO] with arctic natural numbers [ARCTIC]: <<< POL(MARK(x_1)) = [[0A]] + [[1A]] * x_1 >>> <<< POL(s(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(U11(x_1, x_2)) = [[-I]] + [[0A]] * x_1 + [[1A]] * x_2 >>> <<< POL(ACTIVE(x_1)) = [[0A]] + [[0A]] * x_1 >>> <<< POL(tt) = [[2A]] >>> <<< POL(length(x_1)) = [[1A]] + [[0A]] * x_1 >>> <<< POL(cons(x_1, x_2)) = [[2A]] + [[0A]] * x_1 + [[2A]] * x_2 >>> <<< POL(and(x_1, x_2)) = [[1A]] + [[0A]] * x_1 + [[0A]] * x_2 >>> <<< POL(isNatList(x_1)) = [[0A]] + [[0A]] * x_1 >>> <<< POL(isNat(x_1)) = [[0A]] + [[-I]] * x_1 >>> <<< POL(active(x_1)) = [[2A]] + [[0A]] * x_1 >>> <<< POL(mark(x_1)) = [[2A]] + [[0A]] * x_1 >>> <<< POL(zeros) = [[0A]] >>> <<< POL(0) = [[0A]] >>> <<< POL(isNatIList(x_1)) = [[0A]] + [[0A]] * x_1 >>> <<< POL(nil) = [[0A]] >>> The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) s(active(X)) -> s(X) s(mark(X)) -> s(X) isNatList(active(X)) -> isNatList(X) isNatList(mark(X)) -> isNatList(X) isNat(active(X)) -> isNat(X) isNat(mark(X)) -> isNat(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(and(tt, X)) -> mark(X) mark(s(X)) -> active(s(mark(X))) active(isNat(s(V1))) -> mark(isNat(V1)) mark(length(X)) -> active(length(mark(X))) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) mark(isNat(X)) -> active(isNat(X)) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) mark(nil) -> active(nil) active(isNat(0)) -> mark(tt) 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) isNatIList(active(X)) -> isNatIList(X) isNatIList(mark(X)) -> isNatIList(X) ---------------------------------------- (113) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (114) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) The remaining pairs can at least be oriented weakly. Used ordering: Matrix interpretation [MATRO] with arctic natural numbers [ARCTIC]: <<< POL(MARK(x_1)) = [[2A]] + [[1A]] * x_1 >>> <<< POL(s(x_1)) = [[0A]] + [[0A]] * x_1 >>> <<< POL(U11(x_1, x_2)) = [[-I]] + [[-I]] * x_1 + [[1A]] * x_2 >>> <<< POL(ACTIVE(x_1)) = [[2A]] + [[0A]] * x_1 >>> <<< POL(tt) = [[0A]] >>> <<< POL(length(x_1)) = [[0A]] + [[0A]] * x_1 >>> <<< POL(cons(x_1, x_2)) = [[-I]] + [[0A]] * x_1 + [[2A]] * x_2 >>> <<< POL(and(x_1, x_2)) = [[2A]] + [[-I]] * x_1 + [[0A]] * x_2 >>> <<< POL(isNatList(x_1)) = [[0A]] + [[0A]] * x_1 >>> <<< POL(isNat(x_1)) = [[0A]] + [[-I]] * x_1 >>> <<< POL(active(x_1)) = [[2A]] + [[0A]] * x_1 >>> <<< POL(mark(x_1)) = [[2A]] + [[0A]] * x_1 >>> <<< POL(zeros) = [[0A]] >>> <<< POL(0) = [[0A]] >>> <<< POL(isNatIList(x_1)) = [[0A]] + [[0A]] * x_1 >>> <<< POL(nil) = [[0A]] >>> The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) s(active(X)) -> s(X) s(mark(X)) -> s(X) isNatList(active(X)) -> isNatList(X) isNatList(mark(X)) -> isNatList(X) isNat(active(X)) -> isNat(X) isNat(mark(X)) -> isNat(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(and(tt, X)) -> mark(X) mark(s(X)) -> active(s(mark(X))) active(isNat(s(V1))) -> mark(isNat(V1)) mark(length(X)) -> active(length(mark(X))) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) mark(isNat(X)) -> active(isNat(X)) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) mark(nil) -> active(nil) active(isNat(0)) -> mark(tt) 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) isNatIList(active(X)) -> isNatIList(X) isNatIList(mark(X)) -> isNatIList(X) ---------------------------------------- (115) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (116) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) The remaining pairs can at least be oriented weakly. Used ordering: Matrix interpretation [MATRO] with arctic natural numbers [ARCTIC]: <<< POL(MARK(x_1)) = [[2A]] + [[1A]] * x_1 >>> <<< POL(s(x_1)) = [[0A]] + [[0A]] * x_1 >>> <<< POL(U11(x_1, x_2)) = [[-I]] + [[0A]] * x_1 + [[1A]] * x_2 >>> <<< POL(ACTIVE(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(tt) = [[2A]] >>> <<< POL(length(x_1)) = [[0A]] + [[0A]] * x_1 >>> <<< POL(cons(x_1, x_2)) = [[2A]] + [[-I]] * x_1 + [[2A]] * x_2 >>> <<< POL(and(x_1, x_2)) = [[-I]] + [[0A]] * x_1 + [[0A]] * x_2 >>> <<< POL(isNatList(x_1)) = [[0A]] + [[-I]] * x_1 >>> <<< POL(isNat(x_1)) = [[0A]] + [[-I]] * x_1 >>> <<< POL(active(x_1)) = [[2A]] + [[0A]] * x_1 >>> <<< POL(mark(x_1)) = [[2A]] + [[0A]] * x_1 >>> <<< POL(zeros) = [[0A]] >>> <<< POL(0) = [[0A]] >>> <<< POL(isNatIList(x_1)) = [[0A]] + [[-I]] * x_1 >>> <<< POL(nil) = [[0A]] >>> The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) s(active(X)) -> s(X) s(mark(X)) -> s(X) isNatList(active(X)) -> isNatList(X) isNatList(mark(X)) -> isNatList(X) isNat(active(X)) -> isNat(X) isNat(mark(X)) -> isNat(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(and(tt, X)) -> mark(X) mark(s(X)) -> active(s(mark(X))) active(isNat(s(V1))) -> mark(isNat(V1)) mark(length(X)) -> active(length(mark(X))) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) mark(isNat(X)) -> active(isNat(X)) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) mark(nil) -> active(nil) active(isNat(0)) -> mark(tt) 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) isNatIList(active(X)) -> isNatIList(X) isNatIList(mark(X)) -> isNatIList(X) ---------------------------------------- (117) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (118) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) The remaining pairs can at least be oriented weakly. Used ordering: Matrix interpretation [MATRO] with arctic natural numbers [ARCTIC]: <<< POL(MARK(x_1)) = [[0A]] + [[1A]] * x_1 >>> <<< POL(s(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(ACTIVE(x_1)) = [[4A]] + [[0A]] * x_1 >>> <<< POL(U11(x_1, x_2)) = [[3A]] + [[0A]] * x_1 + [[2A]] * x_2 >>> <<< POL(tt) = [[0A]] >>> <<< POL(length(x_1)) = [[3A]] + [[1A]] * x_1 >>> <<< POL(cons(x_1, x_2)) = [[-I]] + [[0A]] * x_1 + [[2A]] * x_2 >>> <<< POL(and(x_1, x_2)) = [[-I]] + [[0A]] * x_1 + [[0A]] * x_2 >>> <<< POL(isNatList(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(isNat(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(active(x_1)) = [[2A]] + [[0A]] * x_1 >>> <<< POL(mark(x_1)) = [[2A]] + [[0A]] * x_1 >>> <<< POL(zeros) = [[0A]] >>> <<< POL(0) = [[0A]] >>> <<< POL(isNatIList(x_1)) = [[-I]] + [[2A]] * x_1 >>> <<< POL(nil) = [[0A]] >>> The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: length(active(X)) -> length(X) length(mark(X)) -> length(X) s(active(X)) -> s(X) s(mark(X)) -> s(X) isNatList(active(X)) -> isNatList(X) isNatList(mark(X)) -> isNatList(X) isNat(active(X)) -> isNat(X) isNat(mark(X)) -> isNat(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(and(tt, X)) -> mark(X) mark(s(X)) -> active(s(mark(X))) active(isNat(s(V1))) -> mark(isNat(V1)) mark(length(X)) -> active(length(mark(X))) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) mark(isNat(X)) -> active(isNat(X)) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) mark(nil) -> active(nil) active(isNat(0)) -> mark(tt) 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) isNatIList(active(X)) -> isNatIList(X) isNatIList(mark(X)) -> isNatIList(X) ---------------------------------------- (119) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (120) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) 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 - 2} POL( MARK_1(x_1) ) = 2 POL( s_1(x_1) ) = max{0, -2} POL( length_1(x_1) ) = x_1 POL( active_1(x_1) ) = x_1 POL( mark_1(x_1) ) = x_1 POL( U11_2(x_1, x_2) ) = 2 POL( and_2(x_1, x_2) ) = 2x_2 POL( isNatList_1(x_1) ) = 0 POL( isNat_1(x_1) ) = 0 POL( cons_2(x_1, x_2) ) = 2 POL( zeros ) = 2 POL( 0 ) = 0 POL( tt ) = 0 POL( isNatIList_1(x_1) ) = 0 POL( nil ) = 2 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: length(active(X)) -> length(X) length(mark(X)) -> length(X) s(active(X)) -> s(X) s(mark(X)) -> s(X) isNatList(active(X)) -> isNatList(X) isNatList(mark(X)) -> isNatList(X) isNat(active(X)) -> isNat(X) isNat(mark(X)) -> isNat(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(and(tt, X)) -> mark(X) mark(s(X)) -> active(s(mark(X))) active(isNat(s(V1))) -> mark(isNat(V1)) mark(length(X)) -> active(length(mark(X))) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) mark(isNat(X)) -> active(isNat(X)) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) mark(nil) -> active(nil) active(isNat(0)) -> mark(tt) 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) isNatIList(active(X)) -> isNatIList(X) isNatIList(mark(X)) -> isNatIList(X) ---------------------------------------- (121) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (122) NonMonReductionPairProof (EQUIVALENT) Using the following max-polynomial ordering, we can orient the general usable rules and all rules from P weakly and some rules from P strictly: Polynomial interpretation with max [POLO,NEGPOLO,MAXPOLO]: POL(0) = 0 POL(ACTIVE(x_1)) = 1 + x_1 POL(MARK(x_1)) = 1 + x_1 POL(U11(x_1, x_2)) = max(0, 1 - x_1) POL(active(x_1)) = x_1 POL(and(x_1, x_2)) = max(0, x_1 + x_2) POL(cons(x_1, x_2)) = max(0, -x_1 - x_2) POL(isNat(x_1)) = 0 POL(isNatIList(x_1)) = 0 POL(isNatList(x_1)) = 1 POL(length(x_1)) = 0 POL(mark(x_1)) = x_1 POL(nil) = 0 POL(s(x_1)) = 1 + x_1 POL(tt) = 0 POL(zeros) = 0 The following pairs can be oriented strictly and are deleted. MARK(s(X)) -> MARK(X) The remaining pairs can at least be oriented weakly. ACTIVE(U11(tt, L)) -> MARK(s(length(L))) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) The following rules are usable: active(zeros) <-> mark(cons(0, zeros)) active(U11(tt, L)) <-> mark(s(length(L))) active(and(tt, X)) <-> mark(X) active(isNat(0)) <-> mark(tt) active(isNat(s(V1))) <-> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) <-> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) <-> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) <-> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) <-> active(zeros) mark(cons(X1, X2)) <-> active(cons(mark(X1), X2)) mark(0) <-> active(0) mark(U11(X1, X2)) <-> active(U11(mark(X1), X2)) mark(tt) <-> active(tt) mark(s(X)) <-> active(s(mark(X))) mark(length(X)) <-> active(length(mark(X))) mark(and(X1, X2)) <-> active(and(mark(X1), X2)) mark(isNat(X)) <-> active(isNat(X)) mark(isNatList(X)) <-> active(isNatList(X)) mark(isNatIList(X)) <-> active(isNatIList(X)) mark(nil) <-> active(nil) 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) U11(mark(X1), X2) <-> U11(X1, X2) U11(X1, mark(X2)) <-> U11(X1, X2) U11(active(X1), X2) <-> U11(X1, X2) U11(X1, active(X2)) <-> U11(X1, X2) s(mark(X)) <-> s(X) s(active(X)) <-> s(X) length(mark(X)) <-> length(X) length(active(X)) <-> length(X) and(mark(X1), X2) <-> and(X1, X2) and(X1, mark(X2)) <-> and(X1, X2) and(active(X1), X2) <-> and(X1, X2) and(X1, active(X2)) <-> and(X1, X2) isNat(mark(X)) <-> isNat(X) isNat(active(X)) <-> isNat(X) isNatList(mark(X)) <-> isNatList(X) isNatList(active(X)) <-> isNatList(X) isNatIList(mark(X)) <-> isNatIList(X) isNatIList(active(X)) <-> isNatIList(X) ---------------------------------------- (123) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (124) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. ACTIVE(U11(tt, L)) -> MARK(s(length(L))) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( ACTIVE_1(x_1) ) = 2x_1 + 1 POL( MARK_1(x_1) ) = 2x_1 + 2 POL( s_1(x_1) ) = max{0, -2} POL( length_1(x_1) ) = 2 POL( active_1(x_1) ) = max{0, -2} POL( mark_1(x_1) ) = 0 POL( U11_2(x_1, x_2) ) = 1 POL( and_2(x_1, x_2) ) = 2x_1 + 2 POL( isNatList_1(x_1) ) = 0 POL( isNat_1(x_1) ) = 0 POL( cons_2(x_1, x_2) ) = 2 POL( zeros ) = 0 POL( 0 ) = 0 POL( tt ) = 0 POL( isNatIList_1(x_1) ) = 0 POL( nil ) = 0 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: length(active(X)) -> length(X) length(mark(X)) -> length(X) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) ---------------------------------------- (125) Obligation: Q DP problem: P is empty. The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) 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) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (126) PisEmptyProof (EQUIVALENT) The TRS P is empty. Hence, there is no (P,Q,R) chain. ---------------------------------------- (127) YES