YES proof of /export/starexec/sandbox2/benchmark/theBenchmark.xml # AProVE Commit ID: 794c25de1cacf0d048858bcd21c9a779e1221865 marcel 20200619 unpublished dirty Termination w.r.t. Q of the given QTRS could be proven: (0) QTRS (1) DependencyPairsProof [EQUIVALENT, 81 ms] (2) QDP (3) DependencyGraphProof [EQUIVALENT, 0 ms] (4) AND (5) QDP (6) UsableRulesProof [EQUIVALENT, 0 ms] (7) QDP (8) QReductionProof [EQUIVALENT, 0 ms] (9) QDP (10) QDPSizeChangeProof [EQUIVALENT, 0 ms] (11) YES (12) QDP (13) UsableRulesProof [EQUIVALENT, 0 ms] (14) QDP (15) QReductionProof [EQUIVALENT, 0 ms] (16) QDP (17) QDPSizeChangeProof [EQUIVALENT, 0 ms] (18) YES (19) QDP (20) UsableRulesProof [EQUIVALENT, 0 ms] (21) QDP (22) QReductionProof [EQUIVALENT, 0 ms] (23) QDP (24) QDPSizeChangeProof [EQUIVALENT, 0 ms] (25) YES (26) QDP (27) UsableRulesProof [EQUIVALENT, 0 ms] (28) QDP (29) QReductionProof [EQUIVALENT, 0 ms] (30) QDP (31) QDPSizeChangeProof [EQUIVALENT, 0 ms] (32) YES (33) QDP (34) UsableRulesProof [EQUIVALENT, 0 ms] (35) QDP (36) QReductionProof [EQUIVALENT, 0 ms] (37) QDP (38) QDPSizeChangeProof [EQUIVALENT, 0 ms] (39) YES (40) QDP (41) UsableRulesProof [EQUIVALENT, 0 ms] (42) QDP (43) QReductionProof [EQUIVALENT, 0 ms] (44) QDP (45) QDPSizeChangeProof [EQUIVALENT, 0 ms] (46) YES (47) QDP (48) UsableRulesProof [EQUIVALENT, 0 ms] (49) QDP (50) QReductionProof [EQUIVALENT, 0 ms] (51) QDP (52) QDPSizeChangeProof [EQUIVALENT, 0 ms] (53) YES (54) QDP (55) UsableRulesProof [EQUIVALENT, 0 ms] (56) QDP (57) QReductionProof [EQUIVALENT, 0 ms] (58) QDP (59) QDPSizeChangeProof [EQUIVALENT, 0 ms] (60) YES (61) QDP (62) UsableRulesProof [EQUIVALENT, 0 ms] (63) QDP (64) QReductionProof [EQUIVALENT, 0 ms] (65) QDP (66) QDPSizeChangeProof [EQUIVALENT, 0 ms] (67) YES (68) QDP (69) UsableRulesProof [EQUIVALENT, 0 ms] (70) QDP (71) QReductionProof [EQUIVALENT, 0 ms] (72) QDP (73) QDPSizeChangeProof [EQUIVALENT, 0 ms] (74) YES (75) QDP (76) UsableRulesProof [EQUIVALENT, 0 ms] (77) QDP (78) QReductionProof [EQUIVALENT, 0 ms] (79) QDP (80) QDPSizeChangeProof [EQUIVALENT, 0 ms] (81) YES (82) QDP (83) UsableRulesProof [EQUIVALENT, 0 ms] (84) QDP (85) QDPQMonotonicMRRProof [EQUIVALENT, 376 ms] (86) QDP (87) QDPOrderProof [EQUIVALENT, 40 ms] (88) QDP (89) QDPOrderProof [EQUIVALENT, 392 ms] (90) QDP (91) QDPOrderProof [EQUIVALENT, 407 ms] (92) QDP (93) QDPQMonotonicMRRProof [EQUIVALENT, 190 ms] (94) QDP (95) QDPQMonotonicMRRProof [EQUIVALENT, 206 ms] (96) QDP (97) DependencyGraphProof [EQUIVALENT, 0 ms] (98) QDP (99) QDPQMonotonicMRRProof [EQUIVALENT, 159 ms] (100) QDP (101) QDPQMonotonicMRRProof [EQUIVALENT, 122 ms] (102) QDP (103) QDPQMonotonicMRRProof [EQUIVALENT, 146 ms] (104) QDP (105) QDPQMonotonicMRRProof [EQUIVALENT, 123 ms] (106) QDP (107) QDPQMonotonicMRRProof [EQUIVALENT, 144 ms] (108) QDP (109) QDPQMonotonicMRRProof [EQUIVALENT, 130 ms] (110) QDP (111) DependencyGraphProof [EQUIVALENT, 0 ms] (112) AND (113) QDP (114) UsableRulesProof [EQUIVALENT, 0 ms] (115) QDP (116) QReductionProof [EQUIVALENT, 0 ms] (117) QDP (118) UsableRulesReductionPairsProof [EQUIVALENT, 0 ms] (119) QDP (120) DependencyGraphProof [EQUIVALENT, 0 ms] (121) TRUE (122) QDP (123) QDPQMonotonicMRRProof [EQUIVALENT, 187 ms] (124) QDP (125) QDPOrderProof [EQUIVALENT, 566 ms] (126) QDP (127) QDPOrderProof [EQUIVALENT, 734 ms] (128) QDP (129) DependencyGraphProof [EQUIVALENT, 0 ms] (130) QDP (131) QDPOrderProof [EQUIVALENT, 546 ms] (132) QDP (133) DependencyGraphProof [EQUIVALENT, 0 ms] (134) QDP (135) QDPOrderProof [EQUIVALENT, 360 ms] (136) QDP (137) DependencyGraphProof [EQUIVALENT, 0 ms] (138) QDP (139) QDPQMonotonicMRRProof [EQUIVALENT, 61 ms] (140) QDP (141) DependencyGraphProof [EQUIVALENT, 0 ms] (142) QDP (143) QDPQMonotonicMRRProof [EQUIVALENT, 77 ms] (144) QDP (145) QDPOrderProof [EQUIVALENT, 337 ms] (146) QDP (147) DependencyGraphProof [EQUIVALENT, 0 ms] (148) TRUE ---------------------------------------- (0) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: active(and(tt, T)) -> mark(T) active(isNatIList(IL)) -> mark(isNatList(IL)) active(isNat(0)) -> mark(tt) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) active(isNatIList(zeros)) -> mark(tt) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatList(nil)) -> mark(tt) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(zeros) -> mark(cons(0, zeros)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) active(uTake1(tt)) -> mark(nil) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) active(uLength(tt, L)) -> mark(s(length(L))) mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(isNatIList(X)) -> active(isNatIList(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNat(X)) -> active(isNat(X)) mark(0) -> active(0) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(nil) -> active(nil) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(uTake1(X)) -> active(uTake1(mark(X))) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) 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) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) uTake1(mark(X)) -> uTake1(X) uTake1(active(X)) -> uTake1(X) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) ---------------------------------------- (1) DependencyPairsProof (EQUIVALENT) Using Dependency Pairs [AG00,LPAR04] we result in the following initial DP problem. ---------------------------------------- (2) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(and(tt, T)) -> MARK(T) ACTIVE(isNatIList(IL)) -> MARK(isNatList(IL)) ACTIVE(isNatIList(IL)) -> ISNATLIST(IL) ACTIVE(isNat(0)) -> MARK(tt) ACTIVE(isNat(s(N))) -> MARK(isNat(N)) ACTIVE(isNat(s(N))) -> ISNAT(N) ACTIVE(isNat(length(L))) -> MARK(isNatList(L)) ACTIVE(isNat(length(L))) -> ISNATLIST(L) ACTIVE(isNatIList(zeros)) -> MARK(tt) ACTIVE(isNatIList(cons(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) ACTIVE(isNatIList(cons(N, IL))) -> AND(isNat(N), isNatIList(IL)) ACTIVE(isNatIList(cons(N, IL))) -> ISNAT(N) ACTIVE(isNatIList(cons(N, IL))) -> ISNATILIST(IL) ACTIVE(isNatList(nil)) -> MARK(tt) ACTIVE(isNatList(cons(N, L))) -> MARK(and(isNat(N), isNatList(L))) ACTIVE(isNatList(cons(N, L))) -> AND(isNat(N), isNatList(L)) ACTIVE(isNatList(cons(N, L))) -> ISNAT(N) ACTIVE(isNatList(cons(N, L))) -> ISNATLIST(L) ACTIVE(isNatList(take(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) ACTIVE(isNatList(take(N, IL))) -> AND(isNat(N), isNatIList(IL)) ACTIVE(isNatList(take(N, IL))) -> ISNAT(N) ACTIVE(isNatList(take(N, IL))) -> ISNATILIST(IL) ACTIVE(zeros) -> MARK(cons(0, zeros)) ACTIVE(zeros) -> CONS(0, zeros) ACTIVE(take(0, IL)) -> MARK(uTake1(isNatIList(IL))) ACTIVE(take(0, IL)) -> UTAKE1(isNatIList(IL)) ACTIVE(take(0, IL)) -> ISNATILIST(IL) ACTIVE(uTake1(tt)) -> MARK(nil) ACTIVE(take(s(M), cons(N, IL))) -> MARK(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) ACTIVE(take(s(M), cons(N, IL))) -> UTAKE2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL) ACTIVE(take(s(M), cons(N, IL))) -> AND(isNat(M), and(isNat(N), isNatIList(IL))) ACTIVE(take(s(M), cons(N, IL))) -> ISNAT(M) ACTIVE(take(s(M), cons(N, IL))) -> AND(isNat(N), isNatIList(IL)) ACTIVE(take(s(M), cons(N, IL))) -> ISNAT(N) ACTIVE(take(s(M), cons(N, IL))) -> ISNATILIST(IL) ACTIVE(uTake2(tt, M, N, IL)) -> MARK(cons(N, take(M, IL))) ACTIVE(uTake2(tt, M, N, IL)) -> CONS(N, take(M, IL)) ACTIVE(uTake2(tt, M, N, IL)) -> TAKE(M, IL) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) ACTIVE(length(cons(N, L))) -> ULENGTH(and(isNat(N), isNatList(L)), L) ACTIVE(length(cons(N, L))) -> AND(isNat(N), isNatList(L)) ACTIVE(length(cons(N, L))) -> ISNAT(N) ACTIVE(length(cons(N, L))) -> ISNATLIST(L) ACTIVE(uLength(tt, L)) -> MARK(s(length(L))) ACTIVE(uLength(tt, L)) -> S(length(L)) ACTIVE(uLength(tt, L)) -> LENGTH(L) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) MARK(and(X1, X2)) -> AND(mark(X1), mark(X2)) MARK(and(X1, X2)) -> MARK(X1) MARK(and(X1, X2)) -> MARK(X2) MARK(tt) -> ACTIVE(tt) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) MARK(isNat(X)) -> ACTIVE(isNat(X)) MARK(0) -> ACTIVE(0) 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(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(nil) -> ACTIVE(nil) MARK(take(X1, X2)) -> ACTIVE(take(mark(X1), mark(X2))) MARK(take(X1, X2)) -> TAKE(mark(X1), mark(X2)) MARK(take(X1, X2)) -> MARK(X1) MARK(take(X1, X2)) -> MARK(X2) MARK(uTake1(X)) -> ACTIVE(uTake1(mark(X))) MARK(uTake1(X)) -> UTAKE1(mark(X)) MARK(uTake1(X)) -> MARK(X) MARK(uTake2(X1, X2, X3, X4)) -> ACTIVE(uTake2(mark(X1), X2, X3, X4)) MARK(uTake2(X1, X2, X3, X4)) -> UTAKE2(mark(X1), X2, X3, X4) MARK(uTake2(X1, X2, X3, X4)) -> MARK(X1) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) MARK(uLength(X1, X2)) -> ULENGTH(mark(X1), X2) MARK(uLength(X1, X2)) -> MARK(X1) 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) ISNATILIST(mark(X)) -> ISNATILIST(X) ISNATILIST(active(X)) -> ISNATILIST(X) ISNATLIST(mark(X)) -> ISNATLIST(X) ISNATLIST(active(X)) -> ISNATLIST(X) ISNAT(mark(X)) -> ISNAT(X) ISNAT(active(X)) -> ISNAT(X) S(mark(X)) -> S(X) S(active(X)) -> S(X) LENGTH(mark(X)) -> LENGTH(X) LENGTH(active(X)) -> LENGTH(X) CONS(mark(X1), X2) -> CONS(X1, X2) CONS(X1, mark(X2)) -> CONS(X1, X2) CONS(active(X1), X2) -> CONS(X1, X2) CONS(X1, active(X2)) -> CONS(X1, X2) TAKE(mark(X1), X2) -> TAKE(X1, X2) TAKE(X1, mark(X2)) -> TAKE(X1, X2) TAKE(active(X1), X2) -> TAKE(X1, X2) TAKE(X1, active(X2)) -> TAKE(X1, X2) UTAKE1(mark(X)) -> UTAKE1(X) UTAKE1(active(X)) -> UTAKE1(X) UTAKE2(mark(X1), X2, X3, X4) -> UTAKE2(X1, X2, X3, X4) UTAKE2(X1, mark(X2), X3, X4) -> UTAKE2(X1, X2, X3, X4) UTAKE2(X1, X2, mark(X3), X4) -> UTAKE2(X1, X2, X3, X4) UTAKE2(X1, X2, X3, mark(X4)) -> UTAKE2(X1, X2, X3, X4) UTAKE2(active(X1), X2, X3, X4) -> UTAKE2(X1, X2, X3, X4) UTAKE2(X1, active(X2), X3, X4) -> UTAKE2(X1, X2, X3, X4) UTAKE2(X1, X2, active(X3), X4) -> UTAKE2(X1, X2, X3, X4) UTAKE2(X1, X2, X3, active(X4)) -> UTAKE2(X1, X2, X3, X4) ULENGTH(mark(X1), X2) -> ULENGTH(X1, X2) ULENGTH(X1, mark(X2)) -> ULENGTH(X1, X2) ULENGTH(active(X1), X2) -> ULENGTH(X1, X2) ULENGTH(X1, active(X2)) -> ULENGTH(X1, X2) The TRS R consists of the following rules: active(and(tt, T)) -> mark(T) active(isNatIList(IL)) -> mark(isNatList(IL)) active(isNat(0)) -> mark(tt) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) active(isNatIList(zeros)) -> mark(tt) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatList(nil)) -> mark(tt) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(zeros) -> mark(cons(0, zeros)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) active(uTake1(tt)) -> mark(nil) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) active(uLength(tt, L)) -> mark(s(length(L))) mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(isNatIList(X)) -> active(isNatIList(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNat(X)) -> active(isNat(X)) mark(0) -> active(0) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(nil) -> active(nil) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(uTake1(X)) -> active(uTake1(mark(X))) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) 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) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) uTake1(mark(X)) -> uTake1(X) uTake1(active(X)) -> uTake1(X) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (3) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 12 SCCs with 44 less nodes. ---------------------------------------- (4) Complex Obligation (AND) ---------------------------------------- (5) Obligation: Q DP problem: The TRS P consists of the following rules: ULENGTH(X1, mark(X2)) -> ULENGTH(X1, X2) ULENGTH(mark(X1), X2) -> ULENGTH(X1, X2) ULENGTH(active(X1), X2) -> ULENGTH(X1, X2) ULENGTH(X1, active(X2)) -> ULENGTH(X1, X2) The TRS R consists of the following rules: active(and(tt, T)) -> mark(T) active(isNatIList(IL)) -> mark(isNatList(IL)) active(isNat(0)) -> mark(tt) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) active(isNatIList(zeros)) -> mark(tt) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatList(nil)) -> mark(tt) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(zeros) -> mark(cons(0, zeros)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) active(uTake1(tt)) -> mark(nil) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) active(uLength(tt, L)) -> mark(s(length(L))) mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(isNatIList(X)) -> active(isNatIList(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNat(X)) -> active(isNat(X)) mark(0) -> active(0) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(nil) -> active(nil) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(uTake1(X)) -> active(uTake1(mark(X))) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) 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) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) uTake1(mark(X)) -> uTake1(X) uTake1(active(X)) -> uTake1(X) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (6) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (7) Obligation: Q DP problem: The TRS P consists of the following rules: ULENGTH(X1, mark(X2)) -> ULENGTH(X1, X2) ULENGTH(mark(X1), X2) -> ULENGTH(X1, X2) ULENGTH(active(X1), X2) -> ULENGTH(X1, X2) ULENGTH(X1, active(X2)) -> ULENGTH(X1, X2) R is empty. The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (8) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) ---------------------------------------- (9) Obligation: Q DP problem: The TRS P consists of the following rules: ULENGTH(X1, mark(X2)) -> ULENGTH(X1, X2) ULENGTH(mark(X1), X2) -> ULENGTH(X1, X2) ULENGTH(active(X1), X2) -> ULENGTH(X1, X2) ULENGTH(X1, active(X2)) -> ULENGTH(X1, X2) R is empty. The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (10) 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: *ULENGTH(X1, mark(X2)) -> ULENGTH(X1, X2) The graph contains the following edges 1 >= 1, 2 > 2 *ULENGTH(mark(X1), X2) -> ULENGTH(X1, X2) The graph contains the following edges 1 > 1, 2 >= 2 *ULENGTH(active(X1), X2) -> ULENGTH(X1, X2) The graph contains the following edges 1 > 1, 2 >= 2 *ULENGTH(X1, active(X2)) -> ULENGTH(X1, X2) The graph contains the following edges 1 >= 1, 2 > 2 ---------------------------------------- (11) YES ---------------------------------------- (12) Obligation: Q DP problem: The TRS P consists of the following rules: UTAKE2(X1, mark(X2), X3, X4) -> UTAKE2(X1, X2, X3, X4) UTAKE2(mark(X1), X2, X3, X4) -> UTAKE2(X1, X2, X3, X4) UTAKE2(X1, X2, mark(X3), X4) -> UTAKE2(X1, X2, X3, X4) UTAKE2(X1, X2, X3, mark(X4)) -> UTAKE2(X1, X2, X3, X4) UTAKE2(active(X1), X2, X3, X4) -> UTAKE2(X1, X2, X3, X4) UTAKE2(X1, active(X2), X3, X4) -> UTAKE2(X1, X2, X3, X4) UTAKE2(X1, X2, active(X3), X4) -> UTAKE2(X1, X2, X3, X4) UTAKE2(X1, X2, X3, active(X4)) -> UTAKE2(X1, X2, X3, X4) The TRS R consists of the following rules: active(and(tt, T)) -> mark(T) active(isNatIList(IL)) -> mark(isNatList(IL)) active(isNat(0)) -> mark(tt) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) active(isNatIList(zeros)) -> mark(tt) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatList(nil)) -> mark(tt) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(zeros) -> mark(cons(0, zeros)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) active(uTake1(tt)) -> mark(nil) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) active(uLength(tt, L)) -> mark(s(length(L))) mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(isNatIList(X)) -> active(isNatIList(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNat(X)) -> active(isNat(X)) mark(0) -> active(0) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(nil) -> active(nil) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(uTake1(X)) -> active(uTake1(mark(X))) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) 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) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) uTake1(mark(X)) -> uTake1(X) uTake1(active(X)) -> uTake1(X) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (13) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (14) Obligation: Q DP problem: The TRS P consists of the following rules: UTAKE2(X1, mark(X2), X3, X4) -> UTAKE2(X1, X2, X3, X4) UTAKE2(mark(X1), X2, X3, X4) -> UTAKE2(X1, X2, X3, X4) UTAKE2(X1, X2, mark(X3), X4) -> UTAKE2(X1, X2, X3, X4) UTAKE2(X1, X2, X3, mark(X4)) -> UTAKE2(X1, X2, X3, X4) UTAKE2(active(X1), X2, X3, X4) -> UTAKE2(X1, X2, X3, X4) UTAKE2(X1, active(X2), X3, X4) -> UTAKE2(X1, X2, X3, X4) UTAKE2(X1, X2, active(X3), X4) -> UTAKE2(X1, X2, X3, X4) UTAKE2(X1, X2, X3, active(X4)) -> UTAKE2(X1, X2, X3, X4) R is empty. The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (15) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) ---------------------------------------- (16) Obligation: Q DP problem: The TRS P consists of the following rules: UTAKE2(X1, mark(X2), X3, X4) -> UTAKE2(X1, X2, X3, X4) UTAKE2(mark(X1), X2, X3, X4) -> UTAKE2(X1, X2, X3, X4) UTAKE2(X1, X2, mark(X3), X4) -> UTAKE2(X1, X2, X3, X4) UTAKE2(X1, X2, X3, mark(X4)) -> UTAKE2(X1, X2, X3, X4) UTAKE2(active(X1), X2, X3, X4) -> UTAKE2(X1, X2, X3, X4) UTAKE2(X1, active(X2), X3, X4) -> UTAKE2(X1, X2, X3, X4) UTAKE2(X1, X2, active(X3), X4) -> UTAKE2(X1, X2, X3, X4) UTAKE2(X1, X2, X3, active(X4)) -> UTAKE2(X1, X2, X3, X4) R is empty. The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (17) 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: *UTAKE2(X1, mark(X2), X3, X4) -> UTAKE2(X1, X2, X3, X4) The graph contains the following edges 1 >= 1, 2 > 2, 3 >= 3, 4 >= 4 *UTAKE2(mark(X1), X2, X3, X4) -> UTAKE2(X1, X2, X3, X4) The graph contains the following edges 1 > 1, 2 >= 2, 3 >= 3, 4 >= 4 *UTAKE2(X1, X2, mark(X3), X4) -> UTAKE2(X1, X2, X3, X4) The graph contains the following edges 1 >= 1, 2 >= 2, 3 > 3, 4 >= 4 *UTAKE2(X1, X2, X3, mark(X4)) -> UTAKE2(X1, X2, X3, X4) The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 3, 4 > 4 *UTAKE2(active(X1), X2, X3, X4) -> UTAKE2(X1, X2, X3, X4) The graph contains the following edges 1 > 1, 2 >= 2, 3 >= 3, 4 >= 4 *UTAKE2(X1, active(X2), X3, X4) -> UTAKE2(X1, X2, X3, X4) The graph contains the following edges 1 >= 1, 2 > 2, 3 >= 3, 4 >= 4 *UTAKE2(X1, X2, active(X3), X4) -> UTAKE2(X1, X2, X3, X4) The graph contains the following edges 1 >= 1, 2 >= 2, 3 > 3, 4 >= 4 *UTAKE2(X1, X2, X3, active(X4)) -> UTAKE2(X1, X2, X3, X4) The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 3, 4 > 4 ---------------------------------------- (18) YES ---------------------------------------- (19) Obligation: Q DP problem: The TRS P consists of the following rules: UTAKE1(active(X)) -> UTAKE1(X) UTAKE1(mark(X)) -> UTAKE1(X) The TRS R consists of the following rules: active(and(tt, T)) -> mark(T) active(isNatIList(IL)) -> mark(isNatList(IL)) active(isNat(0)) -> mark(tt) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) active(isNatIList(zeros)) -> mark(tt) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatList(nil)) -> mark(tt) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(zeros) -> mark(cons(0, zeros)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) active(uTake1(tt)) -> mark(nil) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) active(uLength(tt, L)) -> mark(s(length(L))) mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(isNatIList(X)) -> active(isNatIList(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNat(X)) -> active(isNat(X)) mark(0) -> active(0) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(nil) -> active(nil) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(uTake1(X)) -> active(uTake1(mark(X))) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) 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) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) uTake1(mark(X)) -> uTake1(X) uTake1(active(X)) -> uTake1(X) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (20) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (21) Obligation: Q DP problem: The TRS P consists of the following rules: UTAKE1(active(X)) -> UTAKE1(X) UTAKE1(mark(X)) -> UTAKE1(X) R is empty. The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (22) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) ---------------------------------------- (23) Obligation: Q DP problem: The TRS P consists of the following rules: UTAKE1(active(X)) -> UTAKE1(X) UTAKE1(mark(X)) -> UTAKE1(X) R is empty. The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) 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: *UTAKE1(active(X)) -> UTAKE1(X) The graph contains the following edges 1 > 1 *UTAKE1(mark(X)) -> UTAKE1(X) The graph contains the following edges 1 > 1 ---------------------------------------- (25) YES ---------------------------------------- (26) Obligation: Q DP problem: The TRS P consists of the following rules: TAKE(X1, mark(X2)) -> TAKE(X1, X2) TAKE(mark(X1), X2) -> TAKE(X1, X2) TAKE(active(X1), X2) -> TAKE(X1, X2) TAKE(X1, active(X2)) -> TAKE(X1, X2) The TRS R consists of the following rules: active(and(tt, T)) -> mark(T) active(isNatIList(IL)) -> mark(isNatList(IL)) active(isNat(0)) -> mark(tt) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) active(isNatIList(zeros)) -> mark(tt) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatList(nil)) -> mark(tt) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(zeros) -> mark(cons(0, zeros)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) active(uTake1(tt)) -> mark(nil) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) active(uLength(tt, L)) -> mark(s(length(L))) mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(isNatIList(X)) -> active(isNatIList(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNat(X)) -> active(isNat(X)) mark(0) -> active(0) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(nil) -> active(nil) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(uTake1(X)) -> active(uTake1(mark(X))) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) 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) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) uTake1(mark(X)) -> uTake1(X) uTake1(active(X)) -> uTake1(X) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (27) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (28) Obligation: Q DP problem: The TRS P consists of the following rules: TAKE(X1, mark(X2)) -> TAKE(X1, X2) TAKE(mark(X1), X2) -> TAKE(X1, X2) TAKE(active(X1), X2) -> TAKE(X1, X2) TAKE(X1, active(X2)) -> TAKE(X1, X2) R is empty. The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (29) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) ---------------------------------------- (30) Obligation: Q DP problem: The TRS P consists of the following rules: TAKE(X1, mark(X2)) -> TAKE(X1, X2) TAKE(mark(X1), X2) -> TAKE(X1, X2) TAKE(active(X1), X2) -> TAKE(X1, X2) TAKE(X1, active(X2)) -> TAKE(X1, X2) R is empty. The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (31) QDPSizeChangeProof (EQUIVALENT) By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. From the DPs we obtained the following set of size-change graphs: *TAKE(X1, mark(X2)) -> TAKE(X1, X2) The graph contains the following edges 1 >= 1, 2 > 2 *TAKE(mark(X1), X2) -> TAKE(X1, X2) The graph contains the following edges 1 > 1, 2 >= 2 *TAKE(active(X1), X2) -> TAKE(X1, X2) The graph contains the following edges 1 > 1, 2 >= 2 *TAKE(X1, active(X2)) -> TAKE(X1, X2) The graph contains the following edges 1 >= 1, 2 > 2 ---------------------------------------- (32) YES ---------------------------------------- (33) 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(and(tt, T)) -> mark(T) active(isNatIList(IL)) -> mark(isNatList(IL)) active(isNat(0)) -> mark(tt) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) active(isNatIList(zeros)) -> mark(tt) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatList(nil)) -> mark(tt) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(zeros) -> mark(cons(0, zeros)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) active(uTake1(tt)) -> mark(nil) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) active(uLength(tt, L)) -> mark(s(length(L))) mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(isNatIList(X)) -> active(isNatIList(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNat(X)) -> active(isNat(X)) mark(0) -> active(0) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(nil) -> active(nil) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(uTake1(X)) -> active(uTake1(mark(X))) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) 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) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) uTake1(mark(X)) -> uTake1(X) uTake1(active(X)) -> uTake1(X) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (34) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (35) 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. The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (36) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) ---------------------------------------- (37) 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. The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (38) 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 ---------------------------------------- (39) YES ---------------------------------------- (40) 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(and(tt, T)) -> mark(T) active(isNatIList(IL)) -> mark(isNatList(IL)) active(isNat(0)) -> mark(tt) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) active(isNatIList(zeros)) -> mark(tt) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatList(nil)) -> mark(tt) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(zeros) -> mark(cons(0, zeros)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) active(uTake1(tt)) -> mark(nil) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) active(uLength(tt, L)) -> mark(s(length(L))) mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(isNatIList(X)) -> active(isNatIList(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNat(X)) -> active(isNat(X)) mark(0) -> active(0) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(nil) -> active(nil) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(uTake1(X)) -> active(uTake1(mark(X))) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) 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) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) uTake1(mark(X)) -> uTake1(X) uTake1(active(X)) -> uTake1(X) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (41) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (42) 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. The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (43) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) ---------------------------------------- (44) 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. The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (45) 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 ---------------------------------------- (46) YES ---------------------------------------- (47) 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(and(tt, T)) -> mark(T) active(isNatIList(IL)) -> mark(isNatList(IL)) active(isNat(0)) -> mark(tt) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) active(isNatIList(zeros)) -> mark(tt) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatList(nil)) -> mark(tt) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(zeros) -> mark(cons(0, zeros)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) active(uTake1(tt)) -> mark(nil) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) active(uLength(tt, L)) -> mark(s(length(L))) mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(isNatIList(X)) -> active(isNatIList(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNat(X)) -> active(isNat(X)) mark(0) -> active(0) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(nil) -> active(nil) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(uTake1(X)) -> active(uTake1(mark(X))) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) 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) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) uTake1(mark(X)) -> uTake1(X) uTake1(active(X)) -> uTake1(X) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (48) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (49) 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. The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (50) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) ---------------------------------------- (51) 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. The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (52) 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 ---------------------------------------- (53) YES ---------------------------------------- (54) 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(and(tt, T)) -> mark(T) active(isNatIList(IL)) -> mark(isNatList(IL)) active(isNat(0)) -> mark(tt) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) active(isNatIList(zeros)) -> mark(tt) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatList(nil)) -> mark(tt) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(zeros) -> mark(cons(0, zeros)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) active(uTake1(tt)) -> mark(nil) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) active(uLength(tt, L)) -> mark(s(length(L))) mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(isNatIList(X)) -> active(isNatIList(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNat(X)) -> active(isNat(X)) mark(0) -> active(0) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(nil) -> active(nil) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(uTake1(X)) -> active(uTake1(mark(X))) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) 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) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) uTake1(mark(X)) -> uTake1(X) uTake1(active(X)) -> uTake1(X) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (55) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (56) 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. The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (57) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) ---------------------------------------- (58) 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. The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (59) 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 ---------------------------------------- (60) YES ---------------------------------------- (61) 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(and(tt, T)) -> mark(T) active(isNatIList(IL)) -> mark(isNatList(IL)) active(isNat(0)) -> mark(tt) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) active(isNatIList(zeros)) -> mark(tt) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatList(nil)) -> mark(tt) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(zeros) -> mark(cons(0, zeros)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) active(uTake1(tt)) -> mark(nil) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) active(uLength(tt, L)) -> mark(s(length(L))) mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(isNatIList(X)) -> active(isNatIList(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNat(X)) -> active(isNat(X)) mark(0) -> active(0) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(nil) -> active(nil) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(uTake1(X)) -> active(uTake1(mark(X))) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) 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) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) uTake1(mark(X)) -> uTake1(X) uTake1(active(X)) -> uTake1(X) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (62) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (63) 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. The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (64) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) ---------------------------------------- (65) 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. The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (66) 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 ---------------------------------------- (67) YES ---------------------------------------- (68) 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(and(tt, T)) -> mark(T) active(isNatIList(IL)) -> mark(isNatList(IL)) active(isNat(0)) -> mark(tt) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) active(isNatIList(zeros)) -> mark(tt) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatList(nil)) -> mark(tt) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(zeros) -> mark(cons(0, zeros)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) active(uTake1(tt)) -> mark(nil) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) active(uLength(tt, L)) -> mark(s(length(L))) mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(isNatIList(X)) -> active(isNatIList(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNat(X)) -> active(isNat(X)) mark(0) -> active(0) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(nil) -> active(nil) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(uTake1(X)) -> active(uTake1(mark(X))) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) 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) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) uTake1(mark(X)) -> uTake1(X) uTake1(active(X)) -> uTake1(X) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (69) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (70) 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. The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (71) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) ---------------------------------------- (72) 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. The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (73) 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 ---------------------------------------- (74) YES ---------------------------------------- (75) 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(and(tt, T)) -> mark(T) active(isNatIList(IL)) -> mark(isNatList(IL)) active(isNat(0)) -> mark(tt) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) active(isNatIList(zeros)) -> mark(tt) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatList(nil)) -> mark(tt) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(zeros) -> mark(cons(0, zeros)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) active(uTake1(tt)) -> mark(nil) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) active(uLength(tt, L)) -> mark(s(length(L))) mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(isNatIList(X)) -> active(isNatIList(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNat(X)) -> active(isNat(X)) mark(0) -> active(0) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(nil) -> active(nil) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(uTake1(X)) -> active(uTake1(mark(X))) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) 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) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) uTake1(mark(X)) -> uTake1(X) uTake1(active(X)) -> uTake1(X) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (76) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (77) 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. The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (78) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) ---------------------------------------- (79) 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. The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (80) 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 ---------------------------------------- (81) YES ---------------------------------------- (82) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> MARK(X1) MARK(and(X1, X2)) -> MARK(X2) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(IL)) -> MARK(isNatList(IL)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(N, L))) -> MARK(and(isNat(N), isNatList(L))) ACTIVE(isNatList(take(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) ACTIVE(isNatIList(cons(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) MARK(isNat(X)) -> ACTIVE(isNat(X)) ACTIVE(isNat(s(N))) -> MARK(isNat(N)) ACTIVE(isNat(length(L))) -> MARK(isNatList(L)) MARK(s(X)) -> ACTIVE(s(mark(X))) ACTIVE(take(0, IL)) -> MARK(uTake1(isNatIList(IL))) MARK(uTake1(X)) -> ACTIVE(uTake1(mark(X))) ACTIVE(take(s(M), cons(N, IL))) -> MARK(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) MARK(uTake2(X1, X2, X3, X4)) -> ACTIVE(uTake2(mark(X1), X2, X3, X4)) ACTIVE(uTake2(tt, M, N, IL)) -> MARK(cons(N, take(M, IL))) MARK(cons(X1, X2)) -> ACTIVE(cons(mark(X1), X2)) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) ACTIVE(uLength(tt, L)) -> MARK(s(length(L))) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) MARK(length(X)) -> MARK(X) MARK(zeros) -> ACTIVE(zeros) ACTIVE(zeros) -> MARK(cons(0, zeros)) MARK(cons(X1, X2)) -> MARK(X1) MARK(take(X1, X2)) -> ACTIVE(take(mark(X1), mark(X2))) MARK(take(X1, X2)) -> MARK(X1) MARK(take(X1, X2)) -> MARK(X2) MARK(uTake1(X)) -> MARK(X) MARK(uTake2(X1, X2, X3, X4)) -> MARK(X1) MARK(uLength(X1, X2)) -> MARK(X1) The TRS R consists of the following rules: active(and(tt, T)) -> mark(T) active(isNatIList(IL)) -> mark(isNatList(IL)) active(isNat(0)) -> mark(tt) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) active(isNatIList(zeros)) -> mark(tt) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatList(nil)) -> mark(tt) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(zeros) -> mark(cons(0, zeros)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) active(uTake1(tt)) -> mark(nil) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) active(uLength(tt, L)) -> mark(s(length(L))) mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(isNatIList(X)) -> active(isNatIList(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNat(X)) -> active(isNat(X)) mark(0) -> active(0) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(nil) -> active(nil) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(uTake1(X)) -> active(uTake1(mark(X))) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) 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) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) uTake1(mark(X)) -> uTake1(X) uTake1(active(X)) -> uTake1(X) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (83) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (84) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> MARK(X1) MARK(and(X1, X2)) -> MARK(X2) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(IL)) -> MARK(isNatList(IL)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(N, L))) -> MARK(and(isNat(N), isNatList(L))) ACTIVE(isNatList(take(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) ACTIVE(isNatIList(cons(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) MARK(isNat(X)) -> ACTIVE(isNat(X)) ACTIVE(isNat(s(N))) -> MARK(isNat(N)) ACTIVE(isNat(length(L))) -> MARK(isNatList(L)) MARK(s(X)) -> ACTIVE(s(mark(X))) ACTIVE(take(0, IL)) -> MARK(uTake1(isNatIList(IL))) MARK(uTake1(X)) -> ACTIVE(uTake1(mark(X))) ACTIVE(take(s(M), cons(N, IL))) -> MARK(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) MARK(uTake2(X1, X2, X3, X4)) -> ACTIVE(uTake2(mark(X1), X2, X3, X4)) ACTIVE(uTake2(tt, M, N, IL)) -> MARK(cons(N, take(M, IL))) MARK(cons(X1, X2)) -> ACTIVE(cons(mark(X1), X2)) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) ACTIVE(uLength(tt, L)) -> MARK(s(length(L))) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) MARK(length(X)) -> MARK(X) MARK(zeros) -> ACTIVE(zeros) ACTIVE(zeros) -> MARK(cons(0, zeros)) MARK(cons(X1, X2)) -> MARK(X1) MARK(take(X1, X2)) -> ACTIVE(take(mark(X1), mark(X2))) MARK(take(X1, X2)) -> MARK(X1) MARK(take(X1, X2)) -> MARK(X2) MARK(uTake1(X)) -> MARK(X) MARK(uTake2(X1, X2, X3, X4)) -> MARK(X1) MARK(uLength(X1, X2)) -> MARK(X1) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) active(uTake1(tt)) -> mark(nil) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (85) QDPQMonotonicMRRProof (EQUIVALENT) By using the Q-monotonic rule removal processor with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented such that it always occurs at a strongly monotonic position in a (P,Q,R)-chain. Strictly oriented dependency pairs: MARK(s(X)) -> ACTIVE(s(mark(X))) MARK(uTake1(X)) -> ACTIVE(uTake1(mark(X))) MARK(cons(X1, X2)) -> ACTIVE(cons(mark(X1), X2)) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVE(x_1)) = 2*x_1 POL(MARK(x_1)) = 2 POL(active(x_1)) = 0 POL(and(x_1, x_2)) = 1 POL(cons(x_1, x_2)) = 0 POL(isNat(x_1)) = 1 POL(isNatIList(x_1)) = 1 POL(isNatList(x_1)) = 1 POL(length(x_1)) = 1 POL(mark(x_1)) = 0 POL(nil) = 0 POL(s(x_1)) = 0 POL(take(x_1, x_2)) = 1 POL(tt) = 0 POL(uLength(x_1, x_2)) = 1 POL(uTake1(x_1)) = 0 POL(uTake2(x_1, x_2, x_3, x_4)) = 1 POL(zeros) = 1 ---------------------------------------- (86) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> MARK(X1) MARK(and(X1, X2)) -> MARK(X2) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(IL)) -> MARK(isNatList(IL)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(N, L))) -> MARK(and(isNat(N), isNatList(L))) ACTIVE(isNatList(take(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) ACTIVE(isNatIList(cons(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) MARK(isNat(X)) -> ACTIVE(isNat(X)) ACTIVE(isNat(s(N))) -> MARK(isNat(N)) ACTIVE(isNat(length(L))) -> MARK(isNatList(L)) ACTIVE(take(0, IL)) -> MARK(uTake1(isNatIList(IL))) ACTIVE(take(s(M), cons(N, IL))) -> MARK(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) MARK(uTake2(X1, X2, X3, X4)) -> ACTIVE(uTake2(mark(X1), X2, X3, X4)) ACTIVE(uTake2(tt, M, N, IL)) -> MARK(cons(N, take(M, IL))) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) ACTIVE(uLength(tt, L)) -> MARK(s(length(L))) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) MARK(length(X)) -> MARK(X) MARK(zeros) -> ACTIVE(zeros) ACTIVE(zeros) -> MARK(cons(0, zeros)) MARK(cons(X1, X2)) -> MARK(X1) MARK(take(X1, X2)) -> ACTIVE(take(mark(X1), mark(X2))) MARK(take(X1, X2)) -> MARK(X1) MARK(take(X1, X2)) -> MARK(X2) MARK(uTake1(X)) -> MARK(X) MARK(uTake2(X1, X2, X3, X4)) -> MARK(X1) MARK(uLength(X1, X2)) -> MARK(X1) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) active(uTake1(tt)) -> mark(nil) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (87) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MARK(length(X)) -> MARK(X) MARK(uLength(X1, X2)) -> MARK(X1) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVE(x_1)) = x_1 POL(MARK(x_1)) = x_1 POL(active(x_1)) = x_1 POL(and(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = x_1 + x_2 POL(isNat(x_1)) = 0 POL(isNatIList(x_1)) = 0 POL(isNatList(x_1)) = 0 POL(length(x_1)) = 1 + x_1 POL(mark(x_1)) = x_1 POL(nil) = 0 POL(s(x_1)) = x_1 POL(take(x_1, x_2)) = x_1 + x_2 POL(tt) = 0 POL(uLength(x_1, x_2)) = 1 + x_1 + x_2 POL(uTake1(x_1)) = x_1 POL(uTake2(x_1, x_2, x_3, x_4)) = x_1 + x_2 + x_3 + x_4 POL(zeros) = 0 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) 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) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) active(isNat(0)) -> mark(tt) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) active(uTake1(tt)) -> mark(nil) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) ---------------------------------------- (88) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> MARK(X1) MARK(and(X1, X2)) -> MARK(X2) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(IL)) -> MARK(isNatList(IL)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(N, L))) -> MARK(and(isNat(N), isNatList(L))) ACTIVE(isNatList(take(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) ACTIVE(isNatIList(cons(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) MARK(isNat(X)) -> ACTIVE(isNat(X)) ACTIVE(isNat(s(N))) -> MARK(isNat(N)) ACTIVE(isNat(length(L))) -> MARK(isNatList(L)) ACTIVE(take(0, IL)) -> MARK(uTake1(isNatIList(IL))) ACTIVE(take(s(M), cons(N, IL))) -> MARK(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) MARK(uTake2(X1, X2, X3, X4)) -> ACTIVE(uTake2(mark(X1), X2, X3, X4)) ACTIVE(uTake2(tt, M, N, IL)) -> MARK(cons(N, take(M, IL))) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) ACTIVE(uLength(tt, L)) -> MARK(s(length(L))) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) MARK(zeros) -> ACTIVE(zeros) ACTIVE(zeros) -> MARK(cons(0, zeros)) MARK(cons(X1, X2)) -> MARK(X1) MARK(take(X1, X2)) -> ACTIVE(take(mark(X1), mark(X2))) MARK(take(X1, X2)) -> MARK(X1) MARK(take(X1, X2)) -> MARK(X2) MARK(uTake1(X)) -> MARK(X) MARK(uTake2(X1, X2, X3, X4)) -> MARK(X1) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) active(uTake1(tt)) -> mark(nil) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (89) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. ACTIVE(take(0, IL)) -> MARK(uTake1(isNatIList(IL))) 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( and_2(x_1, x_2) ) = 2x_1 + 2x_2 POL( length_1(x_1) ) = 0 POL( take_2(x_1, x_2) ) = x_1 + x_2 POL( uLength_2(x_1, x_2) ) = max{0, -2} POL( uTake2_4(x_1, ..., x_4) ) = x_1 + x_2 + 2x_3 POL( mark_1(x_1) ) = x_1 POL( active_1(x_1) ) = x_1 POL( tt ) = 0 POL( isNatIList_1(x_1) ) = 0 POL( isNatList_1(x_1) ) = 0 POL( cons_2(x_1, x_2) ) = 2x_1 POL( isNat_1(x_1) ) = 0 POL( s_1(x_1) ) = x_1 POL( zeros ) = 2 POL( 0 ) = 1 POL( uTake1_1(x_1) ) = x_1 POL( nil ) = 0 POL( MARK_1(x_1) ) = 2x_1 + 1 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) 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) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) active(isNat(0)) -> mark(tt) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) active(uTake1(tt)) -> mark(nil) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) ---------------------------------------- (90) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> MARK(X1) MARK(and(X1, X2)) -> MARK(X2) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(IL)) -> MARK(isNatList(IL)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(N, L))) -> MARK(and(isNat(N), isNatList(L))) ACTIVE(isNatList(take(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) ACTIVE(isNatIList(cons(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) MARK(isNat(X)) -> ACTIVE(isNat(X)) ACTIVE(isNat(s(N))) -> MARK(isNat(N)) ACTIVE(isNat(length(L))) -> MARK(isNatList(L)) ACTIVE(take(s(M), cons(N, IL))) -> MARK(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) MARK(uTake2(X1, X2, X3, X4)) -> ACTIVE(uTake2(mark(X1), X2, X3, X4)) ACTIVE(uTake2(tt, M, N, IL)) -> MARK(cons(N, take(M, IL))) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) ACTIVE(uLength(tt, L)) -> MARK(s(length(L))) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) MARK(zeros) -> ACTIVE(zeros) ACTIVE(zeros) -> MARK(cons(0, zeros)) MARK(cons(X1, X2)) -> MARK(X1) MARK(take(X1, X2)) -> ACTIVE(take(mark(X1), mark(X2))) MARK(take(X1, X2)) -> MARK(X1) MARK(take(X1, X2)) -> MARK(X2) MARK(uTake1(X)) -> MARK(X) MARK(uTake2(X1, X2, X3, X4)) -> MARK(X1) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) active(uTake1(tt)) -> mark(nil) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (91) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. ACTIVE(take(s(M), cons(N, IL))) -> MARK(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) MARK(take(X1, X2)) -> MARK(X1) MARK(take(X1, X2)) -> MARK(X2) 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( and_2(x_1, x_2) ) = 2x_1 + 2x_2 POL( length_1(x_1) ) = max{0, -2} POL( take_2(x_1, x_2) ) = x_1 + x_2 + 2 POL( uLength_2(x_1, x_2) ) = max{0, -2} POL( uTake2_4(x_1, ..., x_4) ) = 2x_1 + x_2 + 2x_3 POL( mark_1(x_1) ) = x_1 POL( active_1(x_1) ) = x_1 POL( tt ) = 0 POL( isNatIList_1(x_1) ) = 0 POL( isNatList_1(x_1) ) = 0 POL( cons_2(x_1, x_2) ) = 2x_1 POL( isNat_1(x_1) ) = 0 POL( s_1(x_1) ) = x_1 POL( zeros ) = 0 POL( 0 ) = 0 POL( uTake1_1(x_1) ) = x_1 POL( nil ) = 0 POL( MARK_1(x_1) ) = x_1 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) 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) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) active(isNat(0)) -> mark(tt) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) active(uTake1(tt)) -> mark(nil) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) ---------------------------------------- (92) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> MARK(X1) MARK(and(X1, X2)) -> MARK(X2) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(IL)) -> MARK(isNatList(IL)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(N, L))) -> MARK(and(isNat(N), isNatList(L))) ACTIVE(isNatList(take(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) ACTIVE(isNatIList(cons(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) MARK(isNat(X)) -> ACTIVE(isNat(X)) ACTIVE(isNat(s(N))) -> MARK(isNat(N)) ACTIVE(isNat(length(L))) -> MARK(isNatList(L)) MARK(uTake2(X1, X2, X3, X4)) -> ACTIVE(uTake2(mark(X1), X2, X3, X4)) ACTIVE(uTake2(tt, M, N, IL)) -> MARK(cons(N, take(M, IL))) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) ACTIVE(uLength(tt, L)) -> MARK(s(length(L))) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) MARK(zeros) -> ACTIVE(zeros) ACTIVE(zeros) -> MARK(cons(0, zeros)) MARK(cons(X1, X2)) -> MARK(X1) MARK(take(X1, X2)) -> ACTIVE(take(mark(X1), mark(X2))) MARK(uTake1(X)) -> MARK(X) MARK(uTake2(X1, X2, X3, X4)) -> MARK(X1) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) active(uTake1(tt)) -> mark(nil) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (93) QDPQMonotonicMRRProof (EQUIVALENT) By using the Q-monotonic rule removal processor with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented such that it always occurs at a strongly monotonic position in a (P,Q,R)-chain. Strictly oriented dependency pairs: MARK(take(X1, X2)) -> ACTIVE(take(mark(X1), mark(X2))) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVE(x_1)) = x_1 POL(MARK(x_1)) = 2 POL(active(x_1)) = 0 POL(and(x_1, x_2)) = 2 POL(cons(x_1, x_2)) = 0 POL(isNat(x_1)) = 2 POL(isNatIList(x_1)) = 2 POL(isNatList(x_1)) = 2 POL(length(x_1)) = 2 POL(mark(x_1)) = 0 POL(nil) = 0 POL(s(x_1)) = 0 POL(take(x_1, x_2)) = 0 POL(tt) = 0 POL(uLength(x_1, x_2)) = 2 POL(uTake1(x_1)) = 0 POL(uTake2(x_1, x_2, x_3, x_4)) = 2 POL(zeros) = 2 ---------------------------------------- (94) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> MARK(X1) MARK(and(X1, X2)) -> MARK(X2) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(IL)) -> MARK(isNatList(IL)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(N, L))) -> MARK(and(isNat(N), isNatList(L))) ACTIVE(isNatList(take(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) ACTIVE(isNatIList(cons(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) MARK(isNat(X)) -> ACTIVE(isNat(X)) ACTIVE(isNat(s(N))) -> MARK(isNat(N)) ACTIVE(isNat(length(L))) -> MARK(isNatList(L)) MARK(uTake2(X1, X2, X3, X4)) -> ACTIVE(uTake2(mark(X1), X2, X3, X4)) ACTIVE(uTake2(tt, M, N, IL)) -> MARK(cons(N, take(M, IL))) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) ACTIVE(uLength(tt, L)) -> MARK(s(length(L))) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) MARK(zeros) -> ACTIVE(zeros) ACTIVE(zeros) -> MARK(cons(0, zeros)) MARK(cons(X1, X2)) -> MARK(X1) MARK(uTake1(X)) -> MARK(X) MARK(uTake2(X1, X2, X3, X4)) -> MARK(X1) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) active(uTake1(tt)) -> mark(nil) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (95) QDPQMonotonicMRRProof (EQUIVALENT) By using the Q-monotonic rule removal processor with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented such that it always occurs at a strongly monotonic position in a (P,Q,R)-chain. Strictly oriented dependency pairs: ACTIVE(zeros) -> MARK(cons(0, zeros)) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVE(x_1)) = 2*x_1 POL(MARK(x_1)) = 2*x_1 POL(active(x_1)) = x_1 POL(and(x_1, x_2)) = 2*x_1 + 2*x_2 POL(cons(x_1, x_2)) = 2*x_1 POL(isNat(x_1)) = 0 POL(isNatIList(x_1)) = 0 POL(isNatList(x_1)) = 0 POL(length(x_1)) = 0 POL(mark(x_1)) = x_1 POL(nil) = 0 POL(s(x_1)) = 2*x_1 POL(take(x_1, x_2)) = x_2 POL(tt) = 0 POL(uLength(x_1, x_2)) = 0 POL(uTake1(x_1)) = 2*x_1 POL(uTake2(x_1, x_2, x_3, x_4)) = 2*x_1 + 2*x_3 POL(zeros) = 2 ---------------------------------------- (96) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> MARK(X1) MARK(and(X1, X2)) -> MARK(X2) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(IL)) -> MARK(isNatList(IL)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(N, L))) -> MARK(and(isNat(N), isNatList(L))) ACTIVE(isNatList(take(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) ACTIVE(isNatIList(cons(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) MARK(isNat(X)) -> ACTIVE(isNat(X)) ACTIVE(isNat(s(N))) -> MARK(isNat(N)) ACTIVE(isNat(length(L))) -> MARK(isNatList(L)) MARK(uTake2(X1, X2, X3, X4)) -> ACTIVE(uTake2(mark(X1), X2, X3, X4)) ACTIVE(uTake2(tt, M, N, IL)) -> MARK(cons(N, take(M, IL))) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) ACTIVE(uLength(tt, L)) -> MARK(s(length(L))) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) MARK(zeros) -> ACTIVE(zeros) MARK(cons(X1, X2)) -> MARK(X1) MARK(uTake1(X)) -> MARK(X) MARK(uTake2(X1, X2, X3, X4)) -> MARK(X1) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) active(uTake1(tt)) -> mark(nil) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (97) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (98) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) ACTIVE(uTake2(tt, M, N, IL)) -> MARK(cons(N, take(M, IL))) MARK(cons(X1, X2)) -> MARK(X1) MARK(and(X1, X2)) -> MARK(X1) MARK(and(X1, X2)) -> MARK(X2) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(IL)) -> MARK(isNatList(IL)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(N, L))) -> MARK(and(isNat(N), isNatList(L))) ACTIVE(isNatList(take(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) ACTIVE(isNatIList(cons(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) MARK(isNat(X)) -> ACTIVE(isNat(X)) ACTIVE(isNat(s(N))) -> MARK(isNat(N)) ACTIVE(isNat(length(L))) -> MARK(isNatList(L)) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) ACTIVE(uLength(tt, L)) -> MARK(s(length(L))) MARK(uTake1(X)) -> MARK(X) MARK(uTake2(X1, X2, X3, X4)) -> ACTIVE(uTake2(mark(X1), X2, X3, X4)) MARK(uTake2(X1, X2, X3, X4)) -> MARK(X1) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) active(uTake1(tt)) -> mark(nil) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (99) QDPQMonotonicMRRProof (EQUIVALENT) By using the Q-monotonic rule removal processor with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented such that it always occurs at a strongly monotonic position in a (P,Q,R)-chain. Strictly oriented dependency pairs: ACTIVE(uTake2(tt, M, N, IL)) -> MARK(cons(N, take(M, IL))) MARK(uTake1(X)) -> MARK(X) MARK(uTake2(X1, X2, X3, X4)) -> ACTIVE(uTake2(mark(X1), X2, X3, X4)) MARK(uTake2(X1, X2, X3, X4)) -> MARK(X1) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVE(x_1)) = x_1 POL(MARK(x_1)) = 2*x_1 POL(active(x_1)) = x_1 POL(and(x_1, x_2)) = x_1 + 2*x_2 POL(cons(x_1, x_2)) = x_1 POL(isNat(x_1)) = 0 POL(isNatIList(x_1)) = 0 POL(isNatList(x_1)) = 0 POL(length(x_1)) = 0 POL(mark(x_1)) = x_1 POL(nil) = 0 POL(s(x_1)) = x_1 POL(take(x_1, x_2)) = 2 + 2*x_2 POL(tt) = 0 POL(uLength(x_1, x_2)) = 0 POL(uTake1(x_1)) = 1 + x_1 POL(uTake2(x_1, x_2, x_3, x_4)) = 1 + x_1 + 2*x_3 POL(zeros) = 0 ---------------------------------------- (100) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) MARK(cons(X1, X2)) -> MARK(X1) MARK(and(X1, X2)) -> MARK(X1) MARK(and(X1, X2)) -> MARK(X2) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(IL)) -> MARK(isNatList(IL)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(N, L))) -> MARK(and(isNat(N), isNatList(L))) ACTIVE(isNatList(take(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) ACTIVE(isNatIList(cons(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) MARK(isNat(X)) -> ACTIVE(isNat(X)) ACTIVE(isNat(s(N))) -> MARK(isNat(N)) ACTIVE(isNat(length(L))) -> MARK(isNatList(L)) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) ACTIVE(uLength(tt, L)) -> MARK(s(length(L))) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) active(uTake1(tt)) -> mark(nil) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (101) QDPQMonotonicMRRProof (EQUIVALENT) By using the Q-monotonic rule removal processor with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented such that it always occurs at a strongly monotonic position in a (P,Q,R)-chain. Strictly oriented dependency pairs: MARK(cons(X1, X2)) -> MARK(X1) Used ordering: Polynomial interpretation [POLO]: POL(0) = 1 POL(ACTIVE(x_1)) = 2*x_1 POL(MARK(x_1)) = 2*x_1 POL(active(x_1)) = x_1 POL(and(x_1, x_2)) = 2*x_1 + 2*x_2 POL(cons(x_1, x_2)) = 1 + x_1 POL(isNat(x_1)) = 0 POL(isNatIList(x_1)) = 0 POL(isNatList(x_1)) = 0 POL(length(x_1)) = 0 POL(mark(x_1)) = x_1 POL(nil) = 0 POL(s(x_1)) = 2*x_1 POL(take(x_1, x_2)) = x_2 POL(tt) = 0 POL(uLength(x_1, x_2)) = 0 POL(uTake1(x_1)) = 0 POL(uTake2(x_1, x_2, x_3, x_4)) = 1 + x_3 POL(zeros) = 2 ---------------------------------------- (102) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) MARK(and(X1, X2)) -> MARK(X1) MARK(and(X1, X2)) -> MARK(X2) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(IL)) -> MARK(isNatList(IL)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(N, L))) -> MARK(and(isNat(N), isNatList(L))) ACTIVE(isNatList(take(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) ACTIVE(isNatIList(cons(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) MARK(isNat(X)) -> ACTIVE(isNat(X)) ACTIVE(isNat(s(N))) -> MARK(isNat(N)) ACTIVE(isNat(length(L))) -> MARK(isNatList(L)) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) ACTIVE(uLength(tt, L)) -> MARK(s(length(L))) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) active(uTake1(tt)) -> mark(nil) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (103) QDPQMonotonicMRRProof (EQUIVALENT) By using the Q-monotonic rule removal processor with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented such that it always occurs at a strongly monotonic position in a (P,Q,R)-chain. Strictly oriented rules of the TRS R: active(take(0, IL)) -> mark(uTake1(isNatIList(IL))) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVE(x_1)) = 2*x_1 POL(MARK(x_1)) = 2*x_1 POL(active(x_1)) = x_1 POL(and(x_1, x_2)) = 2*x_1 + 2*x_2 POL(cons(x_1, x_2)) = 2*x_1 + x_2 POL(isNat(x_1)) = 0 POL(isNatIList(x_1)) = 0 POL(isNatList(x_1)) = 0 POL(length(x_1)) = 2*x_1 POL(mark(x_1)) = x_1 POL(nil) = 0 POL(s(x_1)) = x_1 POL(take(x_1, x_2)) = 1 + x_1 + x_2 POL(tt) = 0 POL(uLength(x_1, x_2)) = x_1 + 2*x_2 POL(uTake1(x_1)) = x_1 POL(uTake2(x_1, x_2, x_3, x_4)) = 1 + x_1 + x_2 + 2*x_3 + x_4 POL(zeros) = 0 ---------------------------------------- (104) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) MARK(and(X1, X2)) -> MARK(X1) MARK(and(X1, X2)) -> MARK(X2) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(IL)) -> MARK(isNatList(IL)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(N, L))) -> MARK(and(isNat(N), isNatList(L))) ACTIVE(isNatList(take(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) ACTIVE(isNatIList(cons(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) MARK(isNat(X)) -> ACTIVE(isNat(X)) ACTIVE(isNat(s(N))) -> MARK(isNat(N)) ACTIVE(isNat(length(L))) -> MARK(isNatList(L)) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) ACTIVE(uLength(tt, L)) -> MARK(s(length(L))) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) active(uTake1(tt)) -> mark(nil) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (105) QDPQMonotonicMRRProof (EQUIVALENT) By using the Q-monotonic rule removal processor with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented such that it always occurs at a strongly monotonic position in a (P,Q,R)-chain. Strictly oriented rules of the TRS R: active(uTake1(tt)) -> mark(nil) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVE(x_1)) = x_1 POL(MARK(x_1)) = x_1 POL(active(x_1)) = x_1 POL(and(x_1, x_2)) = 2*x_1 + 2*x_2 POL(cons(x_1, x_2)) = x_1 + x_2 POL(isNat(x_1)) = 0 POL(isNatIList(x_1)) = 0 POL(isNatList(x_1)) = 0 POL(length(x_1)) = 2*x_1 POL(mark(x_1)) = x_1 POL(nil) = 0 POL(s(x_1)) = x_1 POL(take(x_1, x_2)) = x_1 + x_2 POL(tt) = 0 POL(uLength(x_1, x_2)) = 2*x_1 + 2*x_2 POL(uTake1(x_1)) = 1 + x_1 POL(uTake2(x_1, x_2, x_3, x_4)) = x_1 + x_2 + x_3 + x_4 POL(zeros) = 0 ---------------------------------------- (106) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) MARK(and(X1, X2)) -> MARK(X1) MARK(and(X1, X2)) -> MARK(X2) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(IL)) -> MARK(isNatList(IL)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(N, L))) -> MARK(and(isNat(N), isNatList(L))) ACTIVE(isNatList(take(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) ACTIVE(isNatIList(cons(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) MARK(isNat(X)) -> ACTIVE(isNat(X)) ACTIVE(isNat(s(N))) -> MARK(isNat(N)) ACTIVE(isNat(length(L))) -> MARK(isNatList(L)) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) ACTIVE(uLength(tt, L)) -> MARK(s(length(L))) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (107) QDPQMonotonicMRRProof (EQUIVALENT) By using the Q-monotonic rule removal processor with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented such that it always occurs at a strongly monotonic position in a (P,Q,R)-chain. Strictly oriented dependency pairs: ACTIVE(isNatList(take(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVE(x_1)) = 2*x_1 POL(MARK(x_1)) = 2*x_1 POL(active(x_1)) = x_1 POL(and(x_1, x_2)) = 2*x_1 + x_2 POL(cons(x_1, x_2)) = 2*x_1 + x_2 POL(isNat(x_1)) = x_1 POL(isNatIList(x_1)) = 2*x_1 POL(isNatList(x_1)) = 2*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(take(x_1, x_2)) = 2 + x_1 + 2*x_2 POL(tt) = 0 POL(uLength(x_1, x_2)) = 2*x_2 POL(uTake1(x_1)) = 0 POL(uTake2(x_1, x_2, x_3, x_4)) = 2 + x_2 + 2*x_3 + 2*x_4 POL(zeros) = 0 ---------------------------------------- (108) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) MARK(and(X1, X2)) -> MARK(X1) MARK(and(X1, X2)) -> MARK(X2) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(IL)) -> MARK(isNatList(IL)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(N, L))) -> MARK(and(isNat(N), isNatList(L))) ACTIVE(isNatIList(cons(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) MARK(isNat(X)) -> ACTIVE(isNat(X)) ACTIVE(isNat(s(N))) -> MARK(isNat(N)) ACTIVE(isNat(length(L))) -> MARK(isNatList(L)) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) ACTIVE(uLength(tt, L)) -> MARK(s(length(L))) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (109) QDPQMonotonicMRRProof (EQUIVALENT) By using the Q-monotonic rule removal processor with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented such that it always occurs at a strongly monotonic position in a (P,Q,R)-chain. Strictly oriented dependency pairs: ACTIVE(isNat(length(L))) -> MARK(isNatList(L)) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVE(x_1)) = x_1 POL(MARK(x_1)) = x_1 POL(active(x_1)) = x_1 POL(and(x_1, x_2)) = 2*x_1 + x_2 POL(cons(x_1, x_2)) = 2*x_1 + x_2 POL(isNat(x_1)) = 2*x_1 POL(isNatIList(x_1)) = 2*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) = 1 POL(s(x_1)) = x_1 POL(take(x_1, x_2)) = 1 + 2*x_1 + x_2 POL(tt) = 0 POL(uLength(x_1, x_2)) = 1 + 2*x_2 POL(uTake1(x_1)) = 0 POL(uTake2(x_1, x_2, x_3, x_4)) = 1 + 2*x_2 + 2*x_3 + x_4 POL(zeros) = 0 ---------------------------------------- (110) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) MARK(and(X1, X2)) -> MARK(X1) MARK(and(X1, X2)) -> MARK(X2) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(IL)) -> MARK(isNatList(IL)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(N, L))) -> MARK(and(isNat(N), isNatList(L))) ACTIVE(isNatIList(cons(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) MARK(isNat(X)) -> ACTIVE(isNat(X)) ACTIVE(isNat(s(N))) -> MARK(isNat(N)) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) ACTIVE(uLength(tt, L)) -> MARK(s(length(L))) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (111) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 2 SCCs. ---------------------------------------- (112) Complex Obligation (AND) ---------------------------------------- (113) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(isNat(s(N))) -> MARK(isNat(N)) MARK(isNat(X)) -> ACTIVE(isNat(X)) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (114) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (115) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(isNat(s(N))) -> MARK(isNat(N)) MARK(isNat(X)) -> ACTIVE(isNat(X)) R is empty. The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (116) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) ---------------------------------------- (117) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(isNat(s(N))) -> MARK(isNat(N)) MARK(isNat(X)) -> ACTIVE(isNat(X)) R is empty. The set Q consists of the following terms: isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (118) UsableRulesReductionPairsProof (EQUIVALENT) By using the usable rules with reduction pair processor [LPAR04] with a polynomial ordering [POLO], all dependency pairs and the corresponding usable rules [FROCOS05] can be oriented non-strictly. All non-usable rules are removed, and those dependency pairs and usable rules that have been oriented strictly or contain non-usable symbols in their left-hand side are removed as well. The following dependency pairs can be deleted: ACTIVE(isNat(s(N))) -> MARK(isNat(N)) No rules are removed from R. Used ordering: POLO with Polynomial interpretation [POLO]: POL(ACTIVE(x_1)) = x_1 POL(MARK(x_1)) = 2*x_1 POL(isNat(x_1)) = 2*x_1 POL(s(x_1)) = 2*x_1 ---------------------------------------- (119) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(isNat(X)) -> ACTIVE(isNat(X)) R is empty. The set Q consists of the following terms: isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (120) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node. ---------------------------------------- (121) TRUE ---------------------------------------- (122) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> MARK(X1) MARK(and(X1, X2)) -> MARK(X2) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(IL)) -> MARK(isNatList(IL)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(N, L))) -> MARK(and(isNat(N), isNatList(L))) ACTIVE(isNatIList(cons(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) ACTIVE(uLength(tt, L)) -> MARK(s(length(L))) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (123) QDPQMonotonicMRRProof (EQUIVALENT) By using the Q-monotonic rule removal processor with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented such that it always occurs at a strongly monotonic position in a (P,Q,R)-chain. Strictly oriented dependency pairs: ACTIVE(isNatIList(IL)) -> MARK(isNatList(IL)) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVE(x_1)) = x_1 POL(MARK(x_1)) = x_1 POL(active(x_1)) = x_1 POL(and(x_1, x_2)) = 2*x_1 + x_2 POL(cons(x_1, x_2)) = 2*x_1 + x_2 POL(isNat(x_1)) = 2*x_1 POL(isNatIList(x_1)) = 2 + 2*x_1 POL(isNatList(x_1)) = 2*x_1 POL(length(x_1)) = 2*x_1 POL(mark(x_1)) = x_1 POL(nil) = 2 POL(s(x_1)) = x_1 POL(take(x_1, x_2)) = 2 + 2*x_1 + 2*x_2 POL(tt) = 0 POL(uLength(x_1, x_2)) = 2*x_2 POL(uTake1(x_1)) = 0 POL(uTake2(x_1, x_2, x_3, x_4)) = 2 + 2*x_2 + 2*x_3 + 2*x_4 POL(zeros) = 0 ---------------------------------------- (124) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> MARK(X1) MARK(and(X1, X2)) -> MARK(X2) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(N, L))) -> MARK(and(isNat(N), isNatList(L))) ACTIVE(isNatIList(cons(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) ACTIVE(uLength(tt, L)) -> MARK(s(length(L))) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (125) 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(MARK(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(and(x_1, x_2)) = [[-I]] + [[1A]] * x_1 + [[0A]] * x_2 >>> <<< POL(ACTIVE(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(mark(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(tt) = [[0A]] >>> <<< POL(isNatIList(x_1)) = [[0A]] + [[1A]] * x_1 >>> <<< POL(isNatList(x_1)) = [[-I]] + [[1A]] * x_1 >>> <<< POL(cons(x_1, x_2)) = [[0A]] + [[0A]] * x_1 + [[0A]] * x_2 >>> <<< POL(isNat(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(s(x_1)) = [[5A]] + [[0A]] * x_1 >>> <<< POL(length(x_1)) = [[5A]] + [[1A]] * x_1 >>> <<< POL(uLength(x_1, x_2)) = [[5A]] + [[-I]] * x_1 + [[1A]] * x_2 >>> <<< POL(active(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(take(x_1, x_2)) = [[0A]] + [[0A]] * x_1 + [[0A]] * x_2 >>> <<< POL(zeros) = [[0A]] >>> <<< POL(0) = [[0A]] >>> <<< POL(uTake2(x_1, x_2, x_3, x_4)) = [[0A]] + [[-I]] * x_1 + [[0A]] * x_2 + [[0A]] * x_3 + [[0A]] * x_4 >>> <<< POL(uTake1(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: active(and(tt, T)) -> mark(T) mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNat(s(N))) -> mark(isNat(N)) mark(isNat(X)) -> active(isNat(X)) active(isNat(length(L))) -> mark(isNatList(L)) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) mark(isNatIList(X)) -> active(isNatIList(X)) mark(uTake1(X)) -> active(uTake1(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) 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) length(mark(X)) -> length(X) length(active(X)) -> length(X) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) active(isNat(0)) -> mark(tt) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) 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) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) s(mark(X)) -> s(X) s(active(X)) -> s(X) uTake1(mark(X)) -> uTake1(X) uTake1(active(X)) -> uTake1(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) ---------------------------------------- (126) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> MARK(X2) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(N, L))) -> MARK(and(isNat(N), isNatList(L))) ACTIVE(isNatIList(cons(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) ACTIVE(uLength(tt, L)) -> MARK(s(length(L))) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (127) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. ACTIVE(isNatList(cons(N, L))) -> MARK(and(isNat(N), isNatList(L))) 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(and(x_1, x_2)) = [[-I]] + [[-I]] * x_1 + [[0A]] * x_2 >>> <<< POL(ACTIVE(x_1)) = [[1A]] + [[0A]] * x_1 >>> <<< POL(mark(x_1)) = [[1A]] + [[0A]] * x_1 >>> <<< POL(tt) = [[5A]] >>> <<< POL(isNatIList(x_1)) = [[5A]] + [[5A]] * x_1 >>> <<< POL(isNatList(x_1)) = [[-I]] + [[5A]] * x_1 >>> <<< POL(cons(x_1, x_2)) = [[0A]] + [[-I]] * x_1 + [[1A]] * x_2 >>> <<< POL(isNat(x_1)) = [[-I]] + [[5A]] * x_1 >>> <<< POL(s(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(length(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(uLength(x_1, x_2)) = [[-I]] + [[-I]] * x_1 + [[0A]] * x_2 >>> <<< POL(active(x_1)) = [[1A]] + [[0A]] * x_1 >>> <<< POL(take(x_1, x_2)) = [[0A]] + [[-I]] * x_1 + [[0A]] * x_2 >>> <<< POL(zeros) = [[0A]] >>> <<< POL(0) = [[0A]] >>> <<< POL(uTake2(x_1, x_2, x_3, x_4)) = [[-I]] + [[-I]] * x_1 + [[-I]] * x_2 + [[-I]] * x_3 + [[1A]] * x_4 >>> <<< POL(uTake1(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: active(and(tt, T)) -> mark(T) mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNat(s(N))) -> mark(isNat(N)) mark(isNat(X)) -> active(isNat(X)) active(isNat(length(L))) -> mark(isNatList(L)) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) mark(isNatIList(X)) -> active(isNatIList(X)) mark(uTake1(X)) -> active(uTake1(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) 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) length(mark(X)) -> length(X) length(active(X)) -> length(X) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) active(isNat(0)) -> mark(tt) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) 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) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) s(mark(X)) -> s(X) s(active(X)) -> s(X) uTake1(mark(X)) -> uTake1(X) uTake1(active(X)) -> uTake1(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) ---------------------------------------- (128) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> MARK(X2) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatIList(cons(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) ACTIVE(uLength(tt, L)) -> MARK(s(length(L))) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (129) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (130) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) ACTIVE(uLength(tt, L)) -> MARK(s(length(L))) MARK(s(X)) -> MARK(X) MARK(and(X1, X2)) -> MARK(X2) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(cons(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) MARK(length(X)) -> ACTIVE(length(mark(X))) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (131) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. ACTIVE(isNatIList(cons(N, IL))) -> MARK(and(isNat(N), isNatIList(IL))) The remaining pairs can at least be oriented weakly. Used ordering: Matrix interpretation [MATRO] with arctic natural numbers [ARCTIC]: <<< POL(ACTIVE(x_1)) = [[1A]] + [[0A]] * x_1 >>> <<< POL(and(x_1, x_2)) = [[-I]] + [[-I]] * x_1 + [[0A]] * x_2 >>> <<< POL(tt) = [[0A]] >>> <<< POL(MARK(x_1)) = [[1A]] + [[0A]] * x_1 >>> <<< POL(mark(x_1)) = [[1A]] + [[0A]] * x_1 >>> <<< POL(length(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(cons(x_1, x_2)) = [[1A]] + [[0A]] * x_1 + [[1A]] * x_2 >>> <<< POL(uLength(x_1, x_2)) = [[-I]] + [[-I]] * x_1 + [[1A]] * x_2 >>> <<< POL(isNat(x_1)) = [[-I]] + [[1A]] * x_1 >>> <<< POL(isNatList(x_1)) = [[-I]] + [[1A]] * x_1 >>> <<< POL(s(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(isNatIList(x_1)) = [[-I]] + [[1A]] * x_1 >>> <<< POL(active(x_1)) = [[1A]] + [[0A]] * x_1 >>> <<< POL(take(x_1, x_2)) = [[-I]] + [[-I]] * x_1 + [[0A]] * x_2 >>> <<< POL(zeros) = [[0A]] >>> <<< POL(0) = [[1A]] >>> <<< POL(uTake2(x_1, x_2, x_3, x_4)) = [[-I]] + [[-I]] * x_1 + [[-I]] * x_2 + [[0A]] * x_3 + [[1A]] * x_4 >>> <<< POL(uTake1(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: active(and(tt, T)) -> mark(T) mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNat(s(N))) -> mark(isNat(N)) mark(isNat(X)) -> active(isNat(X)) active(isNat(length(L))) -> mark(isNatList(L)) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) mark(isNatIList(X)) -> active(isNatIList(X)) mark(uTake1(X)) -> active(uTake1(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) 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) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) active(isNat(0)) -> mark(tt) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) 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) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) s(mark(X)) -> s(X) s(active(X)) -> s(X) uTake1(mark(X)) -> uTake1(X) uTake1(active(X)) -> uTake1(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) ---------------------------------------- (132) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) ACTIVE(uLength(tt, L)) -> MARK(s(length(L))) MARK(s(X)) -> MARK(X) MARK(and(X1, X2)) -> MARK(X2) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) MARK(length(X)) -> ACTIVE(length(mark(X))) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (133) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (134) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> MARK(X2) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) ACTIVE(uLength(tt, L)) -> MARK(s(length(L))) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (135) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MARK(s(X)) -> MARK(X) 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(and(x_1, x_2)) = [[-I]] + [[-I]] * x_1 + [[0A]] * x_2 >>> <<< POL(ACTIVE(x_1)) = [[1A]] + [[0A]] * x_1 >>> <<< POL(mark(x_1)) = [[1A]] + [[0A]] * x_1 >>> <<< POL(tt) = [[2A]] >>> <<< POL(s(x_1)) = [[2A]] + [[1A]] * x_1 >>> <<< POL(length(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(cons(x_1, x_2)) = [[-I]] + [[0A]] * x_1 + [[1A]] * x_2 >>> <<< POL(uLength(x_1, x_2)) = [[-I]] + [[0A]] * x_1 + [[1A]] * x_2 >>> <<< POL(isNat(x_1)) = [[-I]] + [[2A]] * x_1 >>> <<< POL(isNatList(x_1)) = [[-I]] + [[1A]] * x_1 >>> <<< POL(active(x_1)) = [[1A]] + [[0A]] * x_1 >>> <<< POL(isNatIList(x_1)) = [[-I]] + [[2A]] * x_1 >>> <<< POL(take(x_1, x_2)) = [[2A]] + [[1A]] * x_1 + [[1A]] * x_2 >>> <<< POL(zeros) = [[0A]] >>> <<< POL(0) = [[0A]] >>> <<< POL(uTake2(x_1, x_2, x_3, x_4)) = [[3A]] + [[-I]] * x_1 + [[2A]] * x_2 + [[1A]] * x_3 + [[2A]] * x_4 >>> <<< POL(uTake1(x_1)) = [[0A]] + [[-I]] * x_1 >>> <<< POL(nil) = [[1A]] >>> The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: active(and(tt, T)) -> mark(T) mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNat(s(N))) -> mark(isNat(N)) mark(isNat(X)) -> active(isNat(X)) active(isNat(length(L))) -> mark(isNatList(L)) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) mark(isNatIList(X)) -> active(isNatIList(X)) mark(uTake1(X)) -> active(uTake1(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) 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) length(mark(X)) -> length(X) length(active(X)) -> length(X) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) active(isNat(0)) -> mark(tt) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) 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) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) s(mark(X)) -> s(X) s(active(X)) -> s(X) uTake1(mark(X)) -> uTake1(X) uTake1(active(X)) -> uTake1(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) ---------------------------------------- (136) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> MARK(X2) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) ACTIVE(uLength(tt, L)) -> MARK(s(length(L))) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (137) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (138) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) MARK(and(X1, X2)) -> MARK(X2) MARK(length(X)) -> ACTIVE(length(mark(X))) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (139) QDPQMonotonicMRRProof (EQUIVALENT) By using the Q-monotonic rule removal processor with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented such that it always occurs at a strongly monotonic position in a (P,Q,R)-chain. Strictly oriented dependency pairs: MARK(uLength(X1, X2)) -> ACTIVE(uLength(mark(X1), X2)) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVE(x_1)) = 2*x_1 POL(MARK(x_1)) = 2 POL(active(x_1)) = 0 POL(and(x_1, x_2)) = 1 POL(cons(x_1, x_2)) = 0 POL(isNat(x_1)) = 0 POL(isNatIList(x_1)) = 0 POL(isNatList(x_1)) = 0 POL(length(x_1)) = 1 POL(mark(x_1)) = 0 POL(nil) = 0 POL(s(x_1)) = 0 POL(take(x_1, x_2)) = 0 POL(tt) = 0 POL(uLength(x_1, x_2)) = 0 POL(uTake1(x_1)) = 0 POL(uTake2(x_1, x_2, x_3, x_4)) = 0 POL(zeros) = 0 ---------------------------------------- (140) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) ACTIVE(length(cons(N, L))) -> MARK(uLength(and(isNat(N), isNatList(L)), L)) MARK(and(X1, X2)) -> MARK(X2) MARK(length(X)) -> ACTIVE(length(mark(X))) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (141) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (142) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> MARK(X2) MARK(length(X)) -> ACTIVE(length(mark(X))) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (143) QDPQMonotonicMRRProof (EQUIVALENT) By using the Q-monotonic rule removal processor with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented such that it always occurs at a strongly monotonic position in a (P,Q,R)-chain. Strictly oriented dependency pairs: MARK(length(X)) -> ACTIVE(length(mark(X))) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVE(x_1)) = x_1 POL(MARK(x_1)) = 1 POL(active(x_1)) = 0 POL(and(x_1, x_2)) = 1 POL(cons(x_1, x_2)) = 0 POL(isNat(x_1)) = 0 POL(isNatIList(x_1)) = 0 POL(isNatList(x_1)) = 0 POL(length(x_1)) = 0 POL(mark(x_1)) = 0 POL(nil) = 0 POL(s(x_1)) = 0 POL(take(x_1, x_2)) = 0 POL(tt) = 0 POL(uLength(x_1, x_2)) = 0 POL(uTake1(x_1)) = 0 POL(uTake2(x_1, x_2, x_3, x_4)) = 0 POL(zeros) = 0 ---------------------------------------- (144) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), mark(X2))) ACTIVE(and(tt, T)) -> MARK(T) MARK(and(X1, X2)) -> MARK(X2) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (145) 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), mark(X2))) MARK(and(X1, X2)) -> MARK(X2) The remaining pairs can at least be oriented weakly. Used ordering: Matrix interpretation [MATRO] with arctic natural numbers [ARCTIC]: <<< POL(MARK(x_1)) = [[4A]] + [[3A]] * x_1 >>> <<< POL(and(x_1, x_2)) = [[2A]] + [[-I]] * x_1 + [[1A]] * x_2 >>> <<< POL(ACTIVE(x_1)) = [[-I]] + [[2A]] * x_1 >>> <<< POL(mark(x_1)) = [[1A]] + [[0A]] * x_1 >>> <<< POL(tt) = [[3A]] >>> <<< POL(active(x_1)) = [[1A]] + [[0A]] * x_1 >>> <<< POL(isNatIList(x_1)) = [[-I]] + [[3A]] * x_1 >>> <<< POL(isNatList(x_1)) = [[-I]] + [[1A]] * x_1 >>> <<< POL(cons(x_1, x_2)) = [[1A]] + [[0A]] * x_1 + [[1A]] * x_2 >>> <<< POL(isNat(x_1)) = [[3A]] + [[0A]] * x_1 >>> <<< POL(take(x_1, x_2)) = [[4A]] + [[2A]] * x_1 + [[3A]] * x_2 >>> <<< POL(s(x_1)) = [[3A]] + [[1A]] * x_1 >>> <<< POL(length(x_1)) = [[2A]] + [[1A]] * x_1 >>> <<< POL(zeros) = [[0A]] >>> <<< POL(0) = [[0A]] >>> <<< POL(uTake2(x_1, x_2, x_3, x_4)) = [[5A]] + [[-I]] * x_1 + [[3A]] * x_2 + [[3A]] * x_3 + [[4A]] * x_4 >>> <<< POL(uLength(x_1, x_2)) = [[0A]] + [[0A]] * x_1 + [[2A]] * x_2 >>> <<< POL(uTake1(x_1)) = [[0A]] + [[-I]] * x_1 >>> <<< POL(nil) = [[4A]] >>> The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: active(and(tt, T)) -> mark(T) mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNat(s(N))) -> mark(isNat(N)) mark(isNat(X)) -> active(isNat(X)) active(isNat(length(L))) -> mark(isNatList(L)) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) mark(isNatIList(X)) -> active(isNatIList(X)) mark(uTake1(X)) -> active(uTake1(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) 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) active(isNat(0)) -> mark(tt) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) 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) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) uTake1(mark(X)) -> uTake1(X) uTake1(active(X)) -> uTake1(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) take(mark(X1), X2) -> take(X1, X2) take(X1, mark(X2)) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) ---------------------------------------- (146) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(and(tt, T)) -> MARK(T) The TRS R consists of the following rules: mark(and(X1, X2)) -> active(and(mark(X1), mark(X2))) active(and(tt, T)) -> mark(T) mark(isNatIList(X)) -> active(isNatIList(X)) active(isNatIList(IL)) -> mark(isNatList(IL)) mark(isNatList(X)) -> active(isNatList(X)) active(isNatList(cons(N, L))) -> mark(and(isNat(N), isNatList(L))) active(isNatList(take(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) active(isNatIList(cons(N, IL))) -> mark(and(isNat(N), isNatIList(IL))) mark(isNat(X)) -> active(isNat(X)) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) mark(s(X)) -> active(s(mark(X))) active(zeros) -> mark(cons(0, zeros)) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(uTake1(X)) -> active(uTake1(mark(X))) active(take(s(M), cons(N, IL))) -> mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)) mark(uTake2(X1, X2, X3, X4)) -> active(uTake2(mark(X1), X2, X3, X4)) active(uTake2(tt, M, N, IL)) -> mark(cons(N, take(M, IL))) active(length(cons(N, L))) -> mark(uLength(and(isNat(N), isNatList(L)), L)) mark(uLength(X1, X2)) -> active(uLength(mark(X1), X2)) active(uLength(tt, L)) -> mark(s(length(L))) mark(length(X)) -> active(length(mark(X))) mark(zeros) -> active(zeros) mark(take(X1, X2)) -> active(take(mark(X1), mark(X2))) mark(tt) -> active(tt) mark(0) -> active(0) mark(nil) -> active(nil) take(X1, mark(X2)) -> take(X1, X2) take(mark(X1), X2) -> take(X1, X2) take(active(X1), X2) -> take(X1, X2) take(X1, active(X2)) -> take(X1, X2) 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) active(isNatIList(zeros)) -> mark(tt) active(isNatList(nil)) -> mark(tt) s(active(X)) -> s(X) s(mark(X)) -> s(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) uTake1(active(X)) -> uTake1(X) uTake1(mark(X)) -> uTake1(X) uTake2(X1, mark(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(mark(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, mark(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, mark(X4)) -> uTake2(X1, X2, X3, X4) uTake2(active(X1), X2, X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, active(X2), X3, X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, active(X3), X4) -> uTake2(X1, X2, X3, X4) uTake2(X1, X2, X3, active(X4)) -> uTake2(X1, X2, X3, X4) uLength(X1, mark(X2)) -> uLength(X1, X2) uLength(mark(X1), X2) -> uLength(X1, X2) uLength(active(X1), X2) -> uLength(X1, X2) uLength(X1, active(X2)) -> uLength(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(and(tt, x0)) active(isNatIList(x0)) active(isNat(0)) active(isNat(s(x0))) active(isNat(length(x0))) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(isNatList(take(x0, x1))) active(zeros) active(take(0, x0)) active(uTake1(tt)) active(take(s(x0), cons(x1, x2))) active(uTake2(tt, x0, x1, x2)) active(length(cons(x0, x1))) active(uLength(tt, x0)) mark(and(x0, x1)) mark(tt) mark(isNatIList(x0)) mark(isNatList(x0)) mark(isNat(x0)) mark(0) mark(s(x0)) mark(length(x0)) mark(zeros) mark(cons(x0, x1)) mark(nil) mark(take(x0, x1)) mark(uTake1(x0)) mark(uTake2(x0, x1, x2, x3)) mark(uLength(x0, x1)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatIList(mark(x0)) isNatIList(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNat(mark(x0)) isNat(active(x0)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) take(mark(x0), x1) take(x0, mark(x1)) take(active(x0), x1) take(x0, active(x1)) uTake1(mark(x0)) uTake1(active(x0)) uTake2(mark(x0), x1, x2, x3) uTake2(x0, mark(x1), x2, x3) uTake2(x0, x1, mark(x2), x3) uTake2(x0, x1, x2, mark(x3)) uTake2(active(x0), x1, x2, x3) uTake2(x0, active(x1), x2, x3) uTake2(x0, x1, active(x2), x3) uTake2(x0, x1, x2, active(x3)) uLength(mark(x0), x1) uLength(x0, mark(x1)) uLength(active(x0), x1) uLength(x0, active(x1)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (147) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node. ---------------------------------------- (148) TRUE