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) QTRSRRRProof [EQUIVALENT, 171 ms] (2) QTRS (3) QTRSRRRProof [EQUIVALENT, 47 ms] (4) QTRS (5) QTRSRRRProof [EQUIVALENT, 38 ms] (6) QTRS (7) DependencyPairsProof [EQUIVALENT, 4 ms] (8) QDP (9) DependencyGraphProof [EQUIVALENT, 0 ms] (10) AND (11) QDP (12) UsableRulesProof [EQUIVALENT, 0 ms] (13) QDP (14) QReductionProof [EQUIVALENT, 0 ms] (15) QDP (16) QDPSizeChangeProof [EQUIVALENT, 0 ms] (17) YES (18) QDP (19) UsableRulesProof [EQUIVALENT, 0 ms] (20) QDP (21) QReductionProof [EQUIVALENT, 0 ms] (22) QDP (23) QDPSizeChangeProof [EQUIVALENT, 0 ms] (24) YES (25) QDP (26) UsableRulesProof [EQUIVALENT, 0 ms] (27) QDP (28) QReductionProof [EQUIVALENT, 0 ms] (29) QDP (30) QDPSizeChangeProof [EQUIVALENT, 0 ms] (31) YES (32) QDP (33) UsableRulesProof [EQUIVALENT, 0 ms] (34) QDP (35) QReductionProof [EQUIVALENT, 0 ms] (36) QDP (37) QDPSizeChangeProof [EQUIVALENT, 0 ms] (38) YES (39) QDP (40) UsableRulesProof [EQUIVALENT, 0 ms] (41) QDP (42) QReductionProof [EQUIVALENT, 0 ms] (43) QDP (44) QDPSizeChangeProof [EQUIVALENT, 0 ms] (45) YES (46) QDP (47) UsableRulesProof [EQUIVALENT, 0 ms] (48) QDP (49) QReductionProof [EQUIVALENT, 0 ms] (50) QDP (51) QDPSizeChangeProof [EQUIVALENT, 0 ms] (52) YES (53) QDP (54) UsableRulesProof [EQUIVALENT, 0 ms] (55) QDP (56) QReductionProof [EQUIVALENT, 0 ms] (57) QDP (58) QDPSizeChangeProof [EQUIVALENT, 0 ms] (59) YES (60) QDP (61) UsableRulesProof [EQUIVALENT, 0 ms] (62) QDP (63) QReductionProof [EQUIVALENT, 0 ms] (64) QDP (65) QDPSizeChangeProof [EQUIVALENT, 0 ms] (66) YES (67) QDP (68) UsableRulesProof [EQUIVALENT, 0 ms] (69) QDP (70) QReductionProof [EQUIVALENT, 0 ms] (71) QDP (72) UsableRulesReductionPairsProof [EQUIVALENT, 5 ms] (73) QDP (74) DependencyGraphProof [EQUIVALENT, 0 ms] (75) TRUE (76) QDP (77) UsableRulesProof [EQUIVALENT, 0 ms] (78) QDP (79) MRRProof [EQUIVALENT, 45 ms] (80) QDP (81) QDPOrderProof [EQUIVALENT, 200 ms] (82) QDP (83) QDPQMonotonicMRRProof [EQUIVALENT, 84 ms] (84) QDP (85) DependencyGraphProof [EQUIVALENT, 0 ms] (86) QDP (87) QDPQMonotonicMRRProof [EQUIVALENT, 72 ms] (88) QDP (89) QDPOrderProof [EQUIVALENT, 287 ms] (90) QDP (91) QDPOrderProof [EQUIVALENT, 196 ms] (92) QDP (93) DependencyGraphProof [EQUIVALENT, 0 ms] (94) QDP (95) QDPOrderProof [EQUIVALENT, 285 ms] (96) QDP (97) TransformationProof [SOUND, 0 ms] (98) QDP (99) DependencyGraphProof [EQUIVALENT, 0 ms] (100) QDP (101) QDPOrderProof [EQUIVALENT, 164 ms] (102) QDP (103) TransformationProof [SOUND, 0 ms] (104) QDP (105) TransformationProof [SOUND, 0 ms] (106) QDP (107) TransformationProof [EQUIVALENT, 119 ms] (108) QDP (109) DependencyGraphProof [EQUIVALENT, 0 ms] (110) QDP (111) TransformationProof [EQUIVALENT, 74 ms] (112) QDP (113) DependencyGraphProof [EQUIVALENT, 0 ms] (114) QDP (115) TransformationProof [EQUIVALENT, 125 ms] (116) QDP (117) DependencyGraphProof [EQUIVALENT, 0 ms] (118) QDP (119) TransformationProof [EQUIVALENT, 37 ms] (120) QDP (121) DependencyGraphProof [EQUIVALENT, 0 ms] (122) QDP (123) TransformationProof [EQUIVALENT, 0 ms] (124) QDP (125) DependencyGraphProof [EQUIVALENT, 0 ms] (126) QDP (127) TransformationProof [EQUIVALENT, 0 ms] (128) QDP (129) DependencyGraphProof [EQUIVALENT, 0 ms] (130) AND (131) QDP (132) TransformationProof [EQUIVALENT, 0 ms] (133) QDP (134) DependencyGraphProof [EQUIVALENT, 0 ms] (135) QDP (136) TransformationProof [EQUIVALENT, 0 ms] (137) QDP (138) TransformationProof [EQUIVALENT, 0 ms] (139) QDP (140) TransformationProof [EQUIVALENT, 0 ms] (141) QDP (142) TransformationProof [EQUIVALENT, 0 ms] (143) QDP (144) QDPQMonotonicMRRProof [EQUIVALENT, 242 ms] (145) QDP (146) DependencyGraphProof [EQUIVALENT, 0 ms] (147) QDP (148) QDPQMonotonicMRRProof [EQUIVALENT, 260 ms] (149) QDP (150) DependencyGraphProof [EQUIVALENT, 0 ms] (151) QDP (152) QDPQMonotonicMRRProof [EQUIVALENT, 321 ms] (153) QDP (154) DependencyGraphProof [EQUIVALENT, 0 ms] (155) QDP (156) QDPQMonotonicMRRProof [EQUIVALENT, 248 ms] (157) QDP (158) DependencyGraphProof [EQUIVALENT, 0 ms] (159) QDP (160) QDPOrderProof [EQUIVALENT, 631 ms] (161) QDP (162) DependencyGraphProof [EQUIVALENT, 0 ms] (163) QDP (164) QDPOrderProof [EQUIVALENT, 451 ms] (165) QDP (166) DependencyGraphProof [EQUIVALENT, 0 ms] (167) QDP (168) QDPQMonotonicMRRProof [EQUIVALENT, 121 ms] (169) QDP (170) DependencyGraphProof [EQUIVALENT, 0 ms] (171) QDP (172) NonMonReductionPairProof [EQUIVALENT, 4058 ms] (173) QDP (174) DependencyGraphProof [EQUIVALENT, 0 ms] (175) QDP (176) QDPOrderProof [EQUIVALENT, 0 ms] (177) QDP (178) PisEmptyProof [EQUIVALENT, 0 ms] (179) YES (180) QDP (181) UsableRulesProof [EQUIVALENT, 0 ms] (182) QDP (183) QReductionProof [EQUIVALENT, 0 ms] (184) QDP (185) QDPSizeChangeProof [EQUIVALENT, 0 ms] (186) YES ---------------------------------------- (0) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(length(V1))) -> mark(isNatList(V1)) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(V)) -> mark(isNatList(V)) active(isNatIList(zeros)) -> mark(tt) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(nil)) -> mark(tt) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(nil)) -> mark(0) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) ---------------------------------------- (1) QTRSRRRProof (EQUIVALENT) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(U11(x_1, x_2)) = x_1 + 2*x_2 POL(active(x_1)) = x_1 POL(and(x_1, x_2)) = 2*x_1 + 2*x_2 POL(cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(isNat(x_1)) = x_1 POL(isNatIList(x_1)) = 2*x_1 POL(isNatList(x_1)) = x_1 POL(length(x_1)) = 2*x_1 POL(mark(x_1)) = x_1 POL(nil) = 1 POL(s(x_1)) = x_1 POL(tt) = 0 POL(zeros) = 0 With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly: active(isNatList(nil)) -> mark(tt) active(length(nil)) -> mark(0) ---------------------------------------- (2) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(length(V1))) -> mark(isNatList(V1)) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(V)) -> mark(isNatList(V)) active(isNatIList(zeros)) -> mark(tt) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) ---------------------------------------- (3) QTRSRRRProof (EQUIVALENT) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(U11(x_1, x_2)) = x_1 + 2*x_2 POL(active(x_1)) = x_1 POL(and(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(isNat(x_1)) = x_1 POL(isNatIList(x_1)) = 1 + x_1 POL(isNatList(x_1)) = x_1 POL(length(x_1)) = 2*x_1 POL(mark(x_1)) = x_1 POL(nil) = 0 POL(s(x_1)) = x_1 POL(tt) = 0 POL(zeros) = 0 With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly: active(isNatIList(V)) -> mark(isNatList(V)) active(isNatIList(zeros)) -> mark(tt) ---------------------------------------- (4) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(length(V1))) -> mark(isNatList(V1)) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) ---------------------------------------- (5) QTRSRRRProof (EQUIVALENT) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(U11(x_1, x_2)) = 2 + x_1 + 2*x_2 POL(active(x_1)) = x_1 POL(and(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(isNat(x_1)) = 2*x_1 POL(isNatIList(x_1)) = x_1 POL(isNatList(x_1)) = x_1 POL(length(x_1)) = 2 + 2*x_1 POL(mark(x_1)) = x_1 POL(nil) = 0 POL(s(x_1)) = x_1 POL(tt) = 0 POL(zeros) = 0 With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly: active(isNat(length(V1))) -> mark(isNatList(V1)) ---------------------------------------- (6) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) ---------------------------------------- (7) DependencyPairsProof (EQUIVALENT) Using Dependency Pairs [AG00,LPAR04] we result in the following initial DP problem. ---------------------------------------- (8) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(zeros) -> MARK(cons(0, zeros)) ACTIVE(zeros) -> CONS(0, zeros) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) ACTIVE(U11(tt, L)) -> S(length(L)) ACTIVE(U11(tt, L)) -> LENGTH(L) ACTIVE(and(tt, X)) -> MARK(X) ACTIVE(isNat(0)) -> MARK(tt) ACTIVE(isNat(s(V1))) -> MARK(isNat(V1)) ACTIVE(isNat(s(V1))) -> ISNAT(V1) ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) ACTIVE(isNatIList(cons(V1, V2))) -> AND(isNat(V1), isNatIList(V2)) ACTIVE(isNatIList(cons(V1, V2))) -> ISNAT(V1) ACTIVE(isNatIList(cons(V1, V2))) -> ISNATILIST(V2) ACTIVE(isNatList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatList(V2))) ACTIVE(isNatList(cons(V1, V2))) -> AND(isNat(V1), isNatList(V2)) ACTIVE(isNatList(cons(V1, V2))) -> ISNAT(V1) ACTIVE(isNatList(cons(V1, V2))) -> ISNATLIST(V2) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) ACTIVE(length(cons(N, L))) -> U11^1(and(isNatList(L), isNat(N)), L) ACTIVE(length(cons(N, L))) -> AND(isNatList(L), isNat(N)) ACTIVE(length(cons(N, L))) -> ISNATLIST(L) ACTIVE(length(cons(N, L))) -> ISNAT(N) MARK(zeros) -> ACTIVE(zeros) MARK(cons(X1, X2)) -> ACTIVE(cons(mark(X1), X2)) MARK(cons(X1, X2)) -> CONS(mark(X1), X2) MARK(cons(X1, X2)) -> MARK(X1) MARK(0) -> ACTIVE(0) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) MARK(U11(X1, X2)) -> U11^1(mark(X1), X2) MARK(U11(X1, X2)) -> MARK(X1) MARK(tt) -> ACTIVE(tt) MARK(s(X)) -> ACTIVE(s(mark(X))) MARK(s(X)) -> S(mark(X)) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) MARK(length(X)) -> LENGTH(mark(X)) MARK(length(X)) -> MARK(X) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) MARK(and(X1, X2)) -> AND(mark(X1), X2) MARK(and(X1, X2)) -> MARK(X1) MARK(isNat(X)) -> ACTIVE(isNat(X)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) MARK(nil) -> ACTIVE(nil) CONS(mark(X1), X2) -> CONS(X1, X2) CONS(X1, mark(X2)) -> CONS(X1, X2) CONS(active(X1), X2) -> CONS(X1, X2) CONS(X1, active(X2)) -> CONS(X1, X2) U11^1(mark(X1), X2) -> U11^1(X1, X2) U11^1(X1, mark(X2)) -> U11^1(X1, X2) U11^1(active(X1), X2) -> U11^1(X1, X2) U11^1(X1, active(X2)) -> U11^1(X1, X2) S(mark(X)) -> S(X) S(active(X)) -> S(X) LENGTH(mark(X)) -> LENGTH(X) LENGTH(active(X)) -> LENGTH(X) AND(mark(X1), X2) -> AND(X1, X2) AND(X1, mark(X2)) -> AND(X1, X2) AND(active(X1), X2) -> AND(X1, X2) AND(X1, active(X2)) -> AND(X1, X2) ISNAT(mark(X)) -> ISNAT(X) ISNAT(active(X)) -> ISNAT(X) ISNATLIST(mark(X)) -> ISNATLIST(X) ISNATLIST(active(X)) -> ISNATLIST(X) ISNATILIST(mark(X)) -> ISNATILIST(X) ISNATILIST(active(X)) -> ISNATILIST(X) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (9) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 10 SCCs with 23 less nodes. ---------------------------------------- (10) Complex Obligation (AND) ---------------------------------------- (11) Obligation: Q DP problem: The TRS P consists of the following rules: ISNATILIST(active(X)) -> ISNATILIST(X) ISNATILIST(mark(X)) -> ISNATILIST(X) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (12) 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. ---------------------------------------- (13) Obligation: Q DP problem: The TRS P consists of the following rules: ISNATILIST(active(X)) -> ISNATILIST(X) ISNATILIST(mark(X)) -> ISNATILIST(X) R is empty. The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (14) 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]. cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) ---------------------------------------- (15) 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(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (16) 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 ---------------------------------------- (17) YES ---------------------------------------- (18) Obligation: Q DP problem: The TRS P consists of the following rules: ISNATLIST(active(X)) -> ISNATLIST(X) ISNATLIST(mark(X)) -> ISNATLIST(X) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (19) 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. ---------------------------------------- (20) 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(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (21) 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]. cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) ---------------------------------------- (22) 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(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (23) 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 ---------------------------------------- (24) YES ---------------------------------------- (25) Obligation: Q DP problem: The TRS P consists of the following rules: ISNAT(active(X)) -> ISNAT(X) ISNAT(mark(X)) -> ISNAT(X) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (26) 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. ---------------------------------------- (27) 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(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (28) 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]. cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) ---------------------------------------- (29) 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(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (30) 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 ---------------------------------------- (31) YES ---------------------------------------- (32) Obligation: Q DP problem: The TRS P consists of the following rules: AND(X1, mark(X2)) -> AND(X1, X2) AND(mark(X1), X2) -> AND(X1, X2) AND(active(X1), X2) -> AND(X1, X2) AND(X1, active(X2)) -> AND(X1, X2) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (33) 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. ---------------------------------------- (34) 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(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (35) 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]. cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) ---------------------------------------- (36) 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(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (37) 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 ---------------------------------------- (38) YES ---------------------------------------- (39) Obligation: Q DP problem: The TRS P consists of the following rules: LENGTH(active(X)) -> LENGTH(X) LENGTH(mark(X)) -> LENGTH(X) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (40) 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. ---------------------------------------- (41) 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(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (42) 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]. cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) ---------------------------------------- (43) 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(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (44) QDPSizeChangeProof (EQUIVALENT) By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. From the DPs we obtained the following set of size-change graphs: *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 ---------------------------------------- (45) YES ---------------------------------------- (46) Obligation: Q DP problem: The TRS P consists of the following rules: S(active(X)) -> S(X) S(mark(X)) -> S(X) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (47) 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. ---------------------------------------- (48) 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(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (49) 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]. cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) ---------------------------------------- (50) 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(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (51) 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 ---------------------------------------- (52) YES ---------------------------------------- (53) Obligation: Q DP problem: The TRS P consists of the following rules: U11^1(X1, mark(X2)) -> U11^1(X1, X2) U11^1(mark(X1), X2) -> U11^1(X1, X2) U11^1(active(X1), X2) -> U11^1(X1, X2) U11^1(X1, active(X2)) -> U11^1(X1, X2) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (54) 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. ---------------------------------------- (55) Obligation: Q DP problem: The TRS P consists of the following rules: U11^1(X1, mark(X2)) -> U11^1(X1, X2) U11^1(mark(X1), X2) -> U11^1(X1, X2) U11^1(active(X1), X2) -> U11^1(X1, X2) U11^1(X1, active(X2)) -> U11^1(X1, X2) R is empty. The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (56) 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]. cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) ---------------------------------------- (57) Obligation: Q DP problem: The TRS P consists of the following rules: U11^1(X1, mark(X2)) -> U11^1(X1, X2) U11^1(mark(X1), X2) -> U11^1(X1, X2) U11^1(active(X1), X2) -> U11^1(X1, X2) U11^1(X1, active(X2)) -> U11^1(X1, X2) R is empty. The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (58) QDPSizeChangeProof (EQUIVALENT) By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. From the DPs we obtained the following set of size-change graphs: *U11^1(X1, mark(X2)) -> U11^1(X1, X2) The graph contains the following edges 1 >= 1, 2 > 2 *U11^1(mark(X1), X2) -> U11^1(X1, X2) The graph contains the following edges 1 > 1, 2 >= 2 *U11^1(active(X1), X2) -> U11^1(X1, X2) The graph contains the following edges 1 > 1, 2 >= 2 *U11^1(X1, active(X2)) -> U11^1(X1, X2) The graph contains the following edges 1 >= 1, 2 > 2 ---------------------------------------- (59) YES ---------------------------------------- (60) Obligation: Q DP problem: The TRS P consists of the following rules: CONS(X1, mark(X2)) -> CONS(X1, X2) CONS(mark(X1), X2) -> CONS(X1, X2) CONS(active(X1), X2) -> CONS(X1, X2) CONS(X1, active(X2)) -> CONS(X1, X2) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (61) 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. ---------------------------------------- (62) 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(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (63) 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]. cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) ---------------------------------------- (64) 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(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (65) 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 ---------------------------------------- (66) YES ---------------------------------------- (67) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(isNat(s(V1))) -> MARK(isNat(V1)) MARK(isNat(X)) -> ACTIVE(isNat(X)) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (68) 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. ---------------------------------------- (69) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(isNat(s(V1))) -> MARK(isNat(V1)) MARK(isNat(X)) -> ACTIVE(isNat(X)) R is empty. The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (70) 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(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) ---------------------------------------- (71) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(isNat(s(V1))) -> MARK(isNat(V1)) MARK(isNat(X)) -> ACTIVE(isNat(X)) R is empty. The set Q consists of the following terms: s(mark(x0)) s(active(x0)) isNat(mark(x0)) isNat(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (72) 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(V1))) -> MARK(isNat(V1)) 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 ---------------------------------------- (73) 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: s(mark(x0)) s(active(x0)) isNat(mark(x0)) isNat(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (74) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node. ---------------------------------------- (75) TRUE ---------------------------------------- (76) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(cons(X1, X2)) -> ACTIVE(cons(mark(X1), X2)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(s(X)) -> ACTIVE(s(mark(X))) ACTIVE(and(tt, X)) -> MARK(X) MARK(zeros) -> ACTIVE(zeros) ACTIVE(zeros) -> MARK(cons(0, zeros)) MARK(cons(X1, X2)) -> MARK(X1) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(X1, X2)) -> MARK(X1) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) MARK(length(X)) -> MARK(X) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) MARK(and(X1, X2)) -> MARK(X1) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatList(V2))) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) The TRS R consists of the following rules: active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) active(and(tt, X)) -> mark(X) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(zeros) -> active(zeros) mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) mark(0) -> active(0) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) mark(tt) -> active(tt) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) mark(isNat(X)) -> active(isNat(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(nil) -> active(nil) cons(mark(X1), X2) -> cons(X1, X2) cons(X1, mark(X2)) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(X1, mark(X2)) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) and(mark(X1), X2) -> and(X1, X2) and(X1, mark(X2)) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (77) 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. ---------------------------------------- (78) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(cons(X1, X2)) -> ACTIVE(cons(mark(X1), X2)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(s(X)) -> ACTIVE(s(mark(X))) ACTIVE(and(tt, X)) -> MARK(X) MARK(zeros) -> ACTIVE(zeros) ACTIVE(zeros) -> MARK(cons(0, zeros)) MARK(cons(X1, X2)) -> MARK(X1) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(X1, X2)) -> MARK(X1) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) MARK(length(X)) -> MARK(X) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) MARK(and(X1, X2)) -> MARK(X1) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatList(V2))) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (79) MRRProof (EQUIVALENT) By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented. Strictly oriented dependency pairs: MARK(U11(X1, X2)) -> MARK(X1) MARK(length(X)) -> MARK(X) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVE(x_1)) = 2*x_1 POL(MARK(x_1)) = 2*x_1 POL(U11(x_1, x_2)) = 1 + x_1 + x_2 POL(active(x_1)) = x_1 POL(and(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = x_1 + 2*x_2 POL(isNat(x_1)) = x_1 POL(isNatIList(x_1)) = x_1 POL(isNatList(x_1)) = x_1 POL(length(x_1)) = 1 + x_1 POL(mark(x_1)) = x_1 POL(nil) = 0 POL(s(x_1)) = x_1 POL(tt) = 0 POL(zeros) = 0 ---------------------------------------- (80) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(cons(X1, X2)) -> ACTIVE(cons(mark(X1), X2)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(s(X)) -> ACTIVE(s(mark(X))) ACTIVE(and(tt, X)) -> MARK(X) MARK(zeros) -> ACTIVE(zeros) ACTIVE(zeros) -> MARK(cons(0, zeros)) MARK(cons(X1, X2)) -> MARK(X1) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) MARK(and(X1, X2)) -> MARK(X1) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatList(V2))) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (81) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MARK(cons(X1, X2)) -> ACTIVE(cons(mark(X1), X2)) MARK(s(X)) -> ACTIVE(s(mark(X))) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( ACTIVE_1(x_1) ) = max{0, 2x_1 - 1} POL( U11_2(x_1, x_2) ) = 1 POL( and_2(x_1, x_2) ) = 1 POL( cons_2(x_1, x_2) ) = max{0, -2} POL( length_1(x_1) ) = 1 POL( s_1(x_1) ) = max{0, -2} POL( mark_1(x_1) ) = max{0, -2} POL( active_1(x_1) ) = 2 POL( zeros ) = 1 POL( 0 ) = 0 POL( tt ) = 0 POL( isNatIList_1(x_1) ) = 1 POL( isNat_1(x_1) ) = 0 POL( isNatList_1(x_1) ) = 1 POL( nil ) = 0 POL( MARK_1(x_1) ) = 1 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) ---------------------------------------- (82) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) ACTIVE(and(tt, X)) -> MARK(X) MARK(zeros) -> ACTIVE(zeros) ACTIVE(zeros) -> MARK(cons(0, zeros)) MARK(cons(X1, X2)) -> MARK(X1) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) MARK(and(X1, X2)) -> MARK(X1) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatList(V2))) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (83) 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(U11(x_1, x_2)) = 0 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 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(tt) = 0 POL(zeros) = 2 ---------------------------------------- (84) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) ACTIVE(and(tt, X)) -> MARK(X) MARK(zeros) -> ACTIVE(zeros) MARK(cons(X1, X2)) -> MARK(X1) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) MARK(and(X1, X2)) -> MARK(X1) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatList(V2))) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (85) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (86) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(cons(X1, X2)) -> MARK(X1) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) ACTIVE(and(tt, X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) MARK(and(X1, X2)) -> MARK(X1) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatList(V2))) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (87) 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) = 0 POL(ACTIVE(x_1)) = x_1 POL(MARK(x_1)) = 2*x_1 POL(U11(x_1, x_2)) = 0 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)) = 2*x_1 POL(nil) = 2 POL(s(x_1)) = 2*x_1 POL(tt) = 0 POL(zeros) = 2 ---------------------------------------- (88) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) ACTIVE(and(tt, X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) MARK(and(X1, X2)) -> MARK(X1) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatList(V2))) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) 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. 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(s(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(U11(x_1, x_2)) = [[0A]] + [[3A]] * x_1 + [[4A]] * x_2 >>> <<< POL(ACTIVE(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(mark(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(tt) = [[0A]] >>> <<< POL(length(x_1)) = [[1A]] + [[4A]] * x_1 >>> <<< POL(and(x_1, x_2)) = [[-I]] + [[1A]] * x_1 + [[0A]] * x_2 >>> <<< POL(cons(x_1, x_2)) = [[-I]] + [[1A]] * x_1 + [[0A]] * x_2 >>> <<< POL(isNatList(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(isNat(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(isNatIList(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(active(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(zeros) = [[1A]] >>> <<< POL(0) = [[0A]] >>> <<< POL(nil) = [[0A]] >>> The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) mark(nil) -> active(nil) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) ---------------------------------------- (90) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) ACTIVE(and(tt, X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) ACTIVE(isNatList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatList(V2))) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) 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(isNatList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatList(V2))) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( ACTIVE_1(x_1) ) = max{0, x_1 - 2} POL( U11_2(x_1, x_2) ) = 2 POL( and_2(x_1, x_2) ) = x_2 + 2 POL( length_1(x_1) ) = max{0, -2} POL( mark_1(x_1) ) = 2x_1 POL( cons_2(x_1, x_2) ) = 2x_1 + 2x_2 + 2 POL( active_1(x_1) ) = x_1 POL( zeros ) = 1 POL( 0 ) = 1 POL( tt ) = 0 POL( s_1(x_1) ) = x_1 + 2 POL( isNatIList_1(x_1) ) = 0 POL( isNat_1(x_1) ) = 0 POL( isNatList_1(x_1) ) = 2x_1 + 2 POL( nil ) = 1 POL( MARK_1(x_1) ) = max{0, x_1 - 2} The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) 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) ---------------------------------------- (92) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) ACTIVE(and(tt, X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) MARK(isNatList(X)) -> ACTIVE(isNatList(X)) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (93) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (94) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(and(tt, X)) -> MARK(X) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (95) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. ACTIVE(and(tt, X)) -> MARK(X) The remaining pairs can at least be oriented weakly. Used ordering: Combined order from the following AFS and order. MARK(x1) = MARK(x1) U11(x1, x2) = U11 ACTIVE(x1) = ACTIVE(x1) mark(x1) = x1 tt = tt s(x1) = x1 length(x1) = length and(x1, x2) = and(x2) cons(x1, x2) = cons(x2) isNatList(x1) = isNatList(x1) isNat(x1) = isNat isNatIList(x1) = isNatIList(x1) active(x1) = active(x1) zeros = zeros 0 = 0 nil = nil Recursive path order with status [RPO]. Quasi-Precedence: tt > [and_1, cons_1, isNatIList_1, active_1] > [MARK_1, ACTIVE_1] > [U11, length] > isNat tt > [and_1, cons_1, isNatIList_1, active_1] > 0 > isNat isNatList_1 > [and_1, cons_1, isNatIList_1, active_1] > [MARK_1, ACTIVE_1] > [U11, length] > isNat isNatList_1 > [and_1, cons_1, isNatIList_1, active_1] > 0 > isNat zeros > [and_1, cons_1, isNatIList_1, active_1] > [MARK_1, ACTIVE_1] > [U11, length] > isNat zeros > [and_1, cons_1, isNatIList_1, active_1] > 0 > isNat nil > [and_1, cons_1, isNatIList_1, active_1] > [MARK_1, ACTIVE_1] > [U11, length] > isNat nil > [and_1, cons_1, isNatIList_1, active_1] > 0 > isNat Status: MARK_1: [1] U11: [] ACTIVE_1: [1] tt: multiset status length: [] and_1: [1] cons_1: [1] isNatList_1: multiset status isNat: multiset status isNatIList_1: [1] active_1: multiset status zeros: multiset status 0: multiset status nil: multiset status The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) 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) ---------------------------------------- (96) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (97) TransformationProof (SOUND) By narrowing [LPAR04] the rule MARK(and(X1, X2)) -> ACTIVE(and(mark(X1), X2)) at position [0] we obtained the following new rules [LPAR04]: (MARK(and(x0, x1)) -> ACTIVE(and(x0, x1)),MARK(and(x0, x1)) -> ACTIVE(and(x0, x1))) (MARK(and(cons(x0, x1), y1)) -> ACTIVE(and(active(cons(mark(x0), x1)), y1)),MARK(and(cons(x0, x1), y1)) -> ACTIVE(and(active(cons(mark(x0), x1)), y1))) (MARK(and(s(x0), y1)) -> ACTIVE(and(active(s(mark(x0))), y1)),MARK(and(s(x0), y1)) -> ACTIVE(and(active(s(mark(x0))), y1))) (MARK(and(zeros, y1)) -> ACTIVE(and(active(zeros), y1)),MARK(and(zeros, y1)) -> ACTIVE(and(active(zeros), y1))) (MARK(and(U11(x0, x1), y1)) -> ACTIVE(and(active(U11(mark(x0), x1)), y1)),MARK(and(U11(x0, x1), y1)) -> ACTIVE(and(active(U11(mark(x0), x1)), y1))) (MARK(and(and(x0, x1), y1)) -> ACTIVE(and(active(and(mark(x0), x1)), y1)),MARK(and(and(x0, x1), y1)) -> ACTIVE(and(active(and(mark(x0), x1)), y1))) (MARK(and(length(x0), y1)) -> ACTIVE(and(active(length(mark(x0))), y1)),MARK(and(length(x0), y1)) -> ACTIVE(and(active(length(mark(x0))), y1))) (MARK(and(isNatList(x0), y1)) -> ACTIVE(and(active(isNatList(x0)), y1)),MARK(and(isNatList(x0), y1)) -> ACTIVE(and(active(isNatList(x0)), y1))) (MARK(and(isNatIList(x0), y1)) -> ACTIVE(and(active(isNatIList(x0)), y1)),MARK(and(isNatIList(x0), y1)) -> ACTIVE(and(active(isNatIList(x0)), y1))) (MARK(and(0, y1)) -> ACTIVE(and(active(0), y1)),MARK(and(0, y1)) -> ACTIVE(and(active(0), y1))) (MARK(and(tt, y1)) -> ACTIVE(and(active(tt), y1)),MARK(and(tt, y1)) -> ACTIVE(and(active(tt), y1))) (MARK(and(isNat(x0), y1)) -> ACTIVE(and(active(isNat(x0)), y1)),MARK(and(isNat(x0), y1)) -> ACTIVE(and(active(isNat(x0)), y1))) (MARK(and(nil, y1)) -> ACTIVE(and(active(nil), y1)),MARK(and(nil, y1)) -> ACTIVE(and(active(nil), y1))) ---------------------------------------- (98) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(s(X)) -> MARK(X) MARK(length(X)) -> ACTIVE(length(mark(X))) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(isNatIList(X)) -> ACTIVE(isNatIList(X)) ACTIVE(isNatIList(cons(V1, V2))) -> MARK(and(isNat(V1), isNatIList(V2))) MARK(and(x0, x1)) -> ACTIVE(and(x0, x1)) MARK(and(cons(x0, x1), y1)) -> ACTIVE(and(active(cons(mark(x0), x1)), y1)) MARK(and(s(x0), y1)) -> ACTIVE(and(active(s(mark(x0))), y1)) MARK(and(zeros, y1)) -> ACTIVE(and(active(zeros), y1)) MARK(and(U11(x0, x1), y1)) -> ACTIVE(and(active(U11(mark(x0), x1)), y1)) MARK(and(and(x0, x1), y1)) -> ACTIVE(and(active(and(mark(x0), x1)), y1)) MARK(and(length(x0), y1)) -> ACTIVE(and(active(length(mark(x0))), y1)) MARK(and(isNatList(x0), y1)) -> ACTIVE(and(active(isNatList(x0)), y1)) MARK(and(isNatIList(x0), y1)) -> ACTIVE(and(active(isNatIList(x0)), y1)) MARK(and(0, y1)) -> ACTIVE(and(active(0), y1)) MARK(and(tt, y1)) -> ACTIVE(and(active(tt), y1)) MARK(and(isNat(x0), y1)) -> ACTIVE(and(active(isNat(x0)), y1)) MARK(and(nil, y1)) -> ACTIVE(and(active(nil), y1)) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (99) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 7 less nodes. ---------------------------------------- (100) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(s(X)) -> MARK(X) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(length(X)) -> ACTIVE(length(mark(X))) MARK(and(cons(x0, x1), y1)) -> ACTIVE(and(active(cons(mark(x0), x1)), y1)) MARK(and(s(x0), y1)) -> ACTIVE(and(active(s(mark(x0))), y1)) MARK(and(zeros, y1)) -> ACTIVE(and(active(zeros), y1)) MARK(and(U11(x0, x1), y1)) -> ACTIVE(and(active(U11(mark(x0), x1)), y1)) MARK(and(and(x0, x1), y1)) -> ACTIVE(and(active(and(mark(x0), x1)), y1)) MARK(and(length(x0), y1)) -> ACTIVE(and(active(length(mark(x0))), y1)) MARK(and(isNatList(x0), y1)) -> ACTIVE(and(active(isNatList(x0)), y1)) MARK(and(isNatIList(x0), y1)) -> ACTIVE(and(active(isNatIList(x0)), y1)) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (101) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MARK(and(cons(x0, x1), y1)) -> ACTIVE(and(active(cons(mark(x0), x1)), y1)) MARK(and(s(x0), y1)) -> ACTIVE(and(active(s(mark(x0))), y1)) MARK(and(zeros, y1)) -> ACTIVE(and(active(zeros), y1)) MARK(and(U11(x0, x1), y1)) -> ACTIVE(and(active(U11(mark(x0), x1)), y1)) MARK(and(and(x0, x1), y1)) -> ACTIVE(and(active(and(mark(x0), x1)), y1)) MARK(and(length(x0), y1)) -> ACTIVE(and(active(length(mark(x0))), y1)) MARK(and(isNatList(x0), y1)) -> ACTIVE(and(active(isNatList(x0)), y1)) MARK(and(isNatIList(x0), y1)) -> ACTIVE(and(active(isNatIList(x0)), y1)) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( ACTIVE_1(x_1) ) = x_1 + 1 POL( U11_2(x_1, x_2) ) = 1 POL( and_2(x_1, x_2) ) = 0 POL( length_1(x_1) ) = 1 POL( mark_1(x_1) ) = 2 POL( cons_2(x_1, x_2) ) = max{0, x_1 - 2} POL( active_1(x_1) ) = 2x_1 + 2 POL( zeros ) = 0 POL( 0 ) = 0 POL( tt ) = 0 POL( s_1(x_1) ) = max{0, x_1 - 2} POL( isNatIList_1(x_1) ) = x_1 + 2 POL( isNat_1(x_1) ) = x_1 POL( isNatList_1(x_1) ) = 0 POL( nil ) = 0 POL( MARK_1(x_1) ) = 2 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) 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) ---------------------------------------- (102) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(s(X)) -> MARK(X) MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(length(X)) -> ACTIVE(length(mark(X))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (103) TransformationProof (SOUND) By narrowing [LPAR04] the rule MARK(U11(X1, X2)) -> ACTIVE(U11(mark(X1), X2)) at position [0] we obtained the following new rules [LPAR04]: (MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)),MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1))) (MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)),MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1))) (MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1)),MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1))) (MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)),MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1))) (MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1)),MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1))) (MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)),MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1))) (MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)),MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1))) (MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)),MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1))) (MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1)),MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1))) (MARK(U11(0, y1)) -> ACTIVE(U11(active(0), y1)),MARK(U11(0, y1)) -> ACTIVE(U11(active(0), y1))) (MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1)),MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1))) (MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1)),MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1))) (MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)),MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1))) ---------------------------------------- (104) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(s(X)) -> MARK(X) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(length(X)) -> ACTIVE(length(mark(X))) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)) MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1)) MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)) MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)) MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1)) MARK(U11(0, y1)) -> ACTIVE(U11(active(0), y1)) MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1)) MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1)) MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (105) TransformationProof (SOUND) By narrowing [LPAR04] the rule MARK(length(X)) -> ACTIVE(length(mark(X))) at position [0] we obtained the following new rules [LPAR04]: (MARK(length(x0)) -> ACTIVE(length(x0)),MARK(length(x0)) -> ACTIVE(length(x0))) (MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))),MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1))))) (MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))),MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0)))))) (MARK(length(zeros)) -> ACTIVE(length(active(zeros))),MARK(length(zeros)) -> ACTIVE(length(active(zeros)))) (MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))),MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1))))) (MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))),MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1))))) (MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))),MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0)))))) (MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))),MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0))))) (MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))),MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0))))) (MARK(length(0)) -> ACTIVE(length(active(0))),MARK(length(0)) -> ACTIVE(length(active(0)))) (MARK(length(tt)) -> ACTIVE(length(active(tt))),MARK(length(tt)) -> ACTIVE(length(active(tt)))) (MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))),MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0))))) (MARK(length(nil)) -> ACTIVE(length(active(nil))),MARK(length(nil)) -> ACTIVE(length(active(nil)))) ---------------------------------------- (106) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(s(X)) -> MARK(X) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)) MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1)) MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)) MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)) MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1)) MARK(U11(0, y1)) -> ACTIVE(U11(active(0), y1)) MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1)) MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1)) MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(length(0)) -> ACTIVE(length(active(0))) MARK(length(tt)) -> ACTIVE(length(active(tt))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(length(nil)) -> ACTIVE(length(active(nil))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (107) TransformationProof (EQUIVALENT) By rewriting [LPAR04] the rule MARK(length(0)) -> ACTIVE(length(active(0))) at position [0] we obtained the following new rules [LPAR04]: (MARK(length(0)) -> ACTIVE(length(0)),MARK(length(0)) -> ACTIVE(length(0))) ---------------------------------------- (108) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(s(X)) -> MARK(X) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)) MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1)) MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)) MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)) MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1)) MARK(U11(0, y1)) -> ACTIVE(U11(active(0), y1)) MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1)) MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1)) MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(length(tt)) -> ACTIVE(length(active(tt))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(length(nil)) -> ACTIVE(length(active(nil))) MARK(length(0)) -> ACTIVE(length(0)) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (109) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (110) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1)) MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)) MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)) MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1)) MARK(U11(0, y1)) -> ACTIVE(U11(active(0), y1)) MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1)) MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1)) MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(length(tt)) -> ACTIVE(length(active(tt))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(length(nil)) -> ACTIVE(length(active(nil))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (111) TransformationProof (EQUIVALENT) By rewriting [LPAR04] the rule MARK(length(tt)) -> ACTIVE(length(active(tt))) at position [0] we obtained the following new rules [LPAR04]: (MARK(length(tt)) -> ACTIVE(length(tt)),MARK(length(tt)) -> ACTIVE(length(tt))) ---------------------------------------- (112) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1)) MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)) MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)) MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1)) MARK(U11(0, y1)) -> ACTIVE(U11(active(0), y1)) MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1)) MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1)) MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(length(nil)) -> ACTIVE(length(active(nil))) MARK(length(tt)) -> ACTIVE(length(tt)) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (113) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (114) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1)) MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)) MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)) MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1)) MARK(U11(0, y1)) -> ACTIVE(U11(active(0), y1)) MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1)) MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1)) MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(length(nil)) -> ACTIVE(length(active(nil))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (115) TransformationProof (EQUIVALENT) By rewriting [LPAR04] the rule MARK(length(nil)) -> ACTIVE(length(active(nil))) at position [0] we obtained the following new rules [LPAR04]: (MARK(length(nil)) -> ACTIVE(length(nil)),MARK(length(nil)) -> ACTIVE(length(nil))) ---------------------------------------- (116) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1)) MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)) MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)) MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1)) MARK(U11(0, y1)) -> ACTIVE(U11(active(0), y1)) MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1)) MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1)) MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(length(nil)) -> ACTIVE(length(nil)) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (117) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (118) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1)) MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)) MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)) MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1)) MARK(U11(0, y1)) -> ACTIVE(U11(active(0), y1)) MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1)) MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1)) MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (119) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule MARK(U11(0, y1)) -> ACTIVE(U11(active(0), y1)) at position [0] we obtained the following new rules [LPAR04]: (MARK(U11(0, x1)) -> ACTIVE(U11(0, x1)),MARK(U11(0, x1)) -> ACTIVE(U11(0, x1))) ---------------------------------------- (120) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1)) MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)) MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)) MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1)) MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1)) MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1)) MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(U11(0, x1)) -> ACTIVE(U11(0, x1)) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (121) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (122) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1)) MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)) MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)) MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1)) MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1)) MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1)) MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (123) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule MARK(U11(nil, y1)) -> ACTIVE(U11(active(nil), y1)) at position [0] we obtained the following new rules [LPAR04]: (MARK(U11(nil, x1)) -> ACTIVE(U11(nil, x1)),MARK(U11(nil, x1)) -> ACTIVE(U11(nil, x1))) ---------------------------------------- (124) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1)) MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)) MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)) MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1)) MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1)) MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(U11(nil, x1)) -> ACTIVE(U11(nil, x1)) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (125) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (126) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(X)) -> MARK(X) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1)) MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)) MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)) MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1)) MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1)) MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (127) TransformationProof (EQUIVALENT) By forward instantiating [JAR06] the rule MARK(s(X)) -> MARK(X) we obtained the following new rules [LPAR04]: (MARK(s(s(y_0))) -> MARK(s(y_0)),MARK(s(s(y_0))) -> MARK(s(y_0))) (MARK(s(U11(y_0, y_1))) -> MARK(U11(y_0, y_1)),MARK(s(U11(y_0, y_1))) -> MARK(U11(y_0, y_1))) (MARK(s(U11(cons(y_0, y_1), y_2))) -> MARK(U11(cons(y_0, y_1), y_2)),MARK(s(U11(cons(y_0, y_1), y_2))) -> MARK(U11(cons(y_0, y_1), y_2))) (MARK(s(U11(s(y_0), y_1))) -> MARK(U11(s(y_0), y_1)),MARK(s(U11(s(y_0), y_1))) -> MARK(U11(s(y_0), y_1))) (MARK(s(U11(zeros, y_0))) -> MARK(U11(zeros, y_0)),MARK(s(U11(zeros, y_0))) -> MARK(U11(zeros, y_0))) (MARK(s(U11(U11(y_0, y_1), y_2))) -> MARK(U11(U11(y_0, y_1), y_2)),MARK(s(U11(U11(y_0, y_1), y_2))) -> MARK(U11(U11(y_0, y_1), y_2))) (MARK(s(U11(and(y_0, y_1), y_2))) -> MARK(U11(and(y_0, y_1), y_2)),MARK(s(U11(and(y_0, y_1), y_2))) -> MARK(U11(and(y_0, y_1), y_2))) (MARK(s(U11(length(y_0), y_1))) -> MARK(U11(length(y_0), y_1)),MARK(s(U11(length(y_0), y_1))) -> MARK(U11(length(y_0), y_1))) (MARK(s(U11(isNatList(y_0), y_1))) -> MARK(U11(isNatList(y_0), y_1)),MARK(s(U11(isNatList(y_0), y_1))) -> MARK(U11(isNatList(y_0), y_1))) (MARK(s(U11(isNatIList(y_0), y_1))) -> MARK(U11(isNatIList(y_0), y_1)),MARK(s(U11(isNatIList(y_0), y_1))) -> MARK(U11(isNatIList(y_0), y_1))) (MARK(s(U11(tt, y_0))) -> MARK(U11(tt, y_0)),MARK(s(U11(tt, y_0))) -> MARK(U11(tt, y_0))) (MARK(s(U11(isNat(y_0), y_1))) -> MARK(U11(isNat(y_0), y_1)),MARK(s(U11(isNat(y_0), y_1))) -> MARK(U11(isNat(y_0), y_1))) (MARK(s(length(y_0))) -> MARK(length(y_0)),MARK(s(length(y_0))) -> MARK(length(y_0))) (MARK(s(length(cons(y_0, y_1)))) -> MARK(length(cons(y_0, y_1))),MARK(s(length(cons(y_0, y_1)))) -> MARK(length(cons(y_0, y_1)))) (MARK(s(length(s(y_0)))) -> MARK(length(s(y_0))),MARK(s(length(s(y_0)))) -> MARK(length(s(y_0)))) (MARK(s(length(zeros))) -> MARK(length(zeros)),MARK(s(length(zeros))) -> MARK(length(zeros))) (MARK(s(length(U11(y_0, y_1)))) -> MARK(length(U11(y_0, y_1))),MARK(s(length(U11(y_0, y_1)))) -> MARK(length(U11(y_0, y_1)))) (MARK(s(length(and(y_0, y_1)))) -> MARK(length(and(y_0, y_1))),MARK(s(length(and(y_0, y_1)))) -> MARK(length(and(y_0, y_1)))) (MARK(s(length(length(y_0)))) -> MARK(length(length(y_0))),MARK(s(length(length(y_0)))) -> MARK(length(length(y_0)))) (MARK(s(length(isNatList(y_0)))) -> MARK(length(isNatList(y_0))),MARK(s(length(isNatList(y_0)))) -> MARK(length(isNatList(y_0)))) (MARK(s(length(isNatIList(y_0)))) -> MARK(length(isNatIList(y_0))),MARK(s(length(isNatIList(y_0)))) -> MARK(length(isNatIList(y_0)))) (MARK(s(length(isNat(y_0)))) -> MARK(length(isNat(y_0))),MARK(s(length(isNat(y_0)))) -> MARK(length(isNat(y_0)))) ---------------------------------------- (128) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(U11(cons(x0, x1), y1)) -> ACTIVE(U11(active(cons(mark(x0), x1)), y1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(U11(s(x0), y1)) -> ACTIVE(U11(active(s(mark(x0))), y1)) MARK(U11(zeros, y1)) -> ACTIVE(U11(active(zeros), y1)) MARK(U11(U11(x0, x1), y1)) -> ACTIVE(U11(active(U11(mark(x0), x1)), y1)) MARK(U11(length(x0), y1)) -> ACTIVE(U11(active(length(mark(x0))), y1)) MARK(U11(isNatList(x0), y1)) -> ACTIVE(U11(active(isNatList(x0)), y1)) MARK(U11(isNatIList(x0), y1)) -> ACTIVE(U11(active(isNatIList(x0)), y1)) MARK(U11(tt, y1)) -> ACTIVE(U11(active(tt), y1)) MARK(U11(isNat(x0), y1)) -> ACTIVE(U11(active(isNat(x0)), y1)) MARK(length(x0)) -> ACTIVE(length(x0)) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(s(s(y_0))) -> MARK(s(y_0)) MARK(s(U11(y_0, y_1))) -> MARK(U11(y_0, y_1)) MARK(s(U11(cons(y_0, y_1), y_2))) -> MARK(U11(cons(y_0, y_1), y_2)) MARK(s(U11(s(y_0), y_1))) -> MARK(U11(s(y_0), y_1)) MARK(s(U11(zeros, y_0))) -> MARK(U11(zeros, y_0)) MARK(s(U11(U11(y_0, y_1), y_2))) -> MARK(U11(U11(y_0, y_1), y_2)) MARK(s(U11(and(y_0, y_1), y_2))) -> MARK(U11(and(y_0, y_1), y_2)) MARK(s(U11(length(y_0), y_1))) -> MARK(U11(length(y_0), y_1)) MARK(s(U11(isNatList(y_0), y_1))) -> MARK(U11(isNatList(y_0), y_1)) MARK(s(U11(isNatIList(y_0), y_1))) -> MARK(U11(isNatIList(y_0), y_1)) MARK(s(U11(tt, y_0))) -> MARK(U11(tt, y_0)) MARK(s(U11(isNat(y_0), y_1))) -> MARK(U11(isNat(y_0), y_1)) MARK(s(length(y_0))) -> MARK(length(y_0)) MARK(s(length(cons(y_0, y_1)))) -> MARK(length(cons(y_0, y_1))) MARK(s(length(s(y_0)))) -> MARK(length(s(y_0))) MARK(s(length(zeros))) -> MARK(length(zeros)) MARK(s(length(U11(y_0, y_1)))) -> MARK(length(U11(y_0, y_1))) MARK(s(length(and(y_0, y_1)))) -> MARK(length(and(y_0, y_1))) MARK(s(length(length(y_0)))) -> MARK(length(length(y_0))) MARK(s(length(isNatList(y_0)))) -> MARK(length(isNatList(y_0))) MARK(s(length(isNatIList(y_0)))) -> MARK(length(isNatIList(y_0))) MARK(s(length(isNat(y_0)))) -> MARK(length(isNat(y_0))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (129) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 2 SCCs with 20 less nodes. ---------------------------------------- (130) Complex Obligation (AND) ---------------------------------------- (131) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(s(length(y_0))) -> MARK(length(y_0)) MARK(length(x0)) -> ACTIVE(length(x0)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(s(length(cons(y_0, y_1)))) -> MARK(length(cons(y_0, y_1))) MARK(s(length(s(y_0)))) -> MARK(length(s(y_0))) MARK(s(length(zeros))) -> MARK(length(zeros)) MARK(s(length(U11(y_0, y_1)))) -> MARK(length(U11(y_0, y_1))) MARK(s(length(and(y_0, y_1)))) -> MARK(length(and(y_0, y_1))) MARK(s(length(length(y_0)))) -> MARK(length(length(y_0))) MARK(s(length(isNatList(y_0)))) -> MARK(length(isNatList(y_0))) MARK(s(length(isNatIList(y_0)))) -> MARK(length(isNatIList(y_0))) MARK(s(length(isNat(y_0)))) -> MARK(length(isNat(y_0))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (132) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule MARK(U11(x0, x1)) -> ACTIVE(U11(x0, x1)) we obtained the following new rules [LPAR04]: (MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(and(isNatList(z1), isNat(z0)), z1)),MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(and(isNatList(z1), isNat(z0)), z1))) ---------------------------------------- (133) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(s(length(y_0))) -> MARK(length(y_0)) MARK(length(x0)) -> ACTIVE(length(x0)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(s(length(cons(y_0, y_1)))) -> MARK(length(cons(y_0, y_1))) MARK(s(length(s(y_0)))) -> MARK(length(s(y_0))) MARK(s(length(zeros))) -> MARK(length(zeros)) MARK(s(length(U11(y_0, y_1)))) -> MARK(length(U11(y_0, y_1))) MARK(s(length(and(y_0, y_1)))) -> MARK(length(and(y_0, y_1))) MARK(s(length(length(y_0)))) -> MARK(length(length(y_0))) MARK(s(length(isNatList(y_0)))) -> MARK(length(isNatList(y_0))) MARK(s(length(isNatIList(y_0)))) -> MARK(length(isNatIList(y_0))) MARK(s(length(isNat(y_0)))) -> MARK(length(isNat(y_0))) MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(and(isNatList(z1), isNat(z0)), z1)) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (134) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (135) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(length(y_0))) -> MARK(length(y_0)) MARK(length(x0)) -> ACTIVE(length(x0)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(s(length(cons(y_0, y_1)))) -> MARK(length(cons(y_0, y_1))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(s(length(s(y_0)))) -> MARK(length(s(y_0))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(s(length(zeros))) -> MARK(length(zeros)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(s(length(U11(y_0, y_1)))) -> MARK(length(U11(y_0, y_1))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(s(length(and(y_0, y_1)))) -> MARK(length(and(y_0, y_1))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(s(length(length(y_0)))) -> MARK(length(length(y_0))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(s(length(isNatList(y_0)))) -> MARK(length(isNatList(y_0))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(s(length(isNatIList(y_0)))) -> MARK(length(isNatIList(y_0))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(s(length(isNat(y_0)))) -> MARK(length(isNat(y_0))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (136) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule MARK(U11(and(x0, x1), y1)) -> ACTIVE(U11(active(and(mark(x0), x1)), y1)) we obtained the following new rules [LPAR04]: (MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(active(and(mark(isNatList(z1)), isNat(z0))), z1)),MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(active(and(mark(isNatList(z1)), isNat(z0))), z1))) ---------------------------------------- (137) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(length(y_0))) -> MARK(length(y_0)) MARK(length(x0)) -> ACTIVE(length(x0)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(s(length(cons(y_0, y_1)))) -> MARK(length(cons(y_0, y_1))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(s(length(s(y_0)))) -> MARK(length(s(y_0))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(s(length(zeros))) -> MARK(length(zeros)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(s(length(U11(y_0, y_1)))) -> MARK(length(U11(y_0, y_1))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(s(length(and(y_0, y_1)))) -> MARK(length(and(y_0, y_1))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(s(length(length(y_0)))) -> MARK(length(length(y_0))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(s(length(isNatList(y_0)))) -> MARK(length(isNatList(y_0))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(s(length(isNatIList(y_0)))) -> MARK(length(isNatIList(y_0))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(s(length(isNat(y_0)))) -> MARK(length(isNat(y_0))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(active(and(mark(isNatList(z1)), isNat(z0))), z1)) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (138) TransformationProof (EQUIVALENT) By forward instantiating [JAR06] the rule MARK(length(x0)) -> ACTIVE(length(x0)) we obtained the following new rules [LPAR04]: (MARK(length(cons(y_0, y_1))) -> ACTIVE(length(cons(y_0, y_1))),MARK(length(cons(y_0, y_1))) -> ACTIVE(length(cons(y_0, y_1)))) ---------------------------------------- (139) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(length(y_0))) -> MARK(length(y_0)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(s(length(cons(y_0, y_1)))) -> MARK(length(cons(y_0, y_1))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(s(length(s(y_0)))) -> MARK(length(s(y_0))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(s(length(zeros))) -> MARK(length(zeros)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(s(length(U11(y_0, y_1)))) -> MARK(length(U11(y_0, y_1))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(s(length(and(y_0, y_1)))) -> MARK(length(and(y_0, y_1))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(s(length(length(y_0)))) -> MARK(length(length(y_0))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(s(length(isNatList(y_0)))) -> MARK(length(isNatList(y_0))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(s(length(isNatIList(y_0)))) -> MARK(length(isNatIList(y_0))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(s(length(isNat(y_0)))) -> MARK(length(isNat(y_0))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(active(and(mark(isNatList(z1)), isNat(z0))), z1)) MARK(length(cons(y_0, y_1))) -> ACTIVE(length(cons(y_0, y_1))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (140) TransformationProof (EQUIVALENT) By forward instantiating [JAR06] the rule MARK(s(length(y_0))) -> MARK(length(y_0)) we obtained the following new rules [LPAR04]: (MARK(s(length(cons(y_0, y_1)))) -> MARK(length(cons(y_0, y_1))),MARK(s(length(cons(y_0, y_1)))) -> MARK(length(cons(y_0, y_1)))) (MARK(s(length(s(y_0)))) -> MARK(length(s(y_0))),MARK(s(length(s(y_0)))) -> MARK(length(s(y_0)))) (MARK(s(length(zeros))) -> MARK(length(zeros)),MARK(s(length(zeros))) -> MARK(length(zeros))) (MARK(s(length(U11(y_0, y_1)))) -> MARK(length(U11(y_0, y_1))),MARK(s(length(U11(y_0, y_1)))) -> MARK(length(U11(y_0, y_1)))) (MARK(s(length(and(y_0, y_1)))) -> MARK(length(and(y_0, y_1))),MARK(s(length(and(y_0, y_1)))) -> MARK(length(and(y_0, y_1)))) (MARK(s(length(length(y_0)))) -> MARK(length(length(y_0))),MARK(s(length(length(y_0)))) -> MARK(length(length(y_0)))) (MARK(s(length(isNatList(y_0)))) -> MARK(length(isNatList(y_0))),MARK(s(length(isNatList(y_0)))) -> MARK(length(isNatList(y_0)))) (MARK(s(length(isNatIList(y_0)))) -> MARK(length(isNatIList(y_0))),MARK(s(length(isNatIList(y_0)))) -> MARK(length(isNatIList(y_0)))) (MARK(s(length(isNat(y_0)))) -> MARK(length(isNat(y_0))),MARK(s(length(isNat(y_0)))) -> MARK(length(isNat(y_0)))) ---------------------------------------- (141) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) ACTIVE(U11(tt, L)) -> MARK(s(length(L))) MARK(s(length(cons(y_0, y_1)))) -> MARK(length(cons(y_0, y_1))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(s(length(s(y_0)))) -> MARK(length(s(y_0))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(s(length(zeros))) -> MARK(length(zeros)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(s(length(U11(y_0, y_1)))) -> MARK(length(U11(y_0, y_1))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(s(length(and(y_0, y_1)))) -> MARK(length(and(y_0, y_1))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(s(length(length(y_0)))) -> MARK(length(length(y_0))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(s(length(isNatList(y_0)))) -> MARK(length(isNatList(y_0))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(s(length(isNatIList(y_0)))) -> MARK(length(isNatIList(y_0))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(s(length(isNat(y_0)))) -> MARK(length(isNat(y_0))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(active(and(mark(isNatList(z1)), isNat(z0))), z1)) MARK(length(cons(y_0, y_1))) -> ACTIVE(length(cons(y_0, y_1))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (142) TransformationProof (EQUIVALENT) By forward instantiating [JAR06] the rule ACTIVE(U11(tt, L)) -> MARK(s(length(L))) we obtained the following new rules [LPAR04]: (ACTIVE(U11(tt, cons(y_0, y_1))) -> MARK(s(length(cons(y_0, y_1)))),ACTIVE(U11(tt, cons(y_0, y_1))) -> MARK(s(length(cons(y_0, y_1))))) (ACTIVE(U11(tt, s(y_0))) -> MARK(s(length(s(y_0)))),ACTIVE(U11(tt, s(y_0))) -> MARK(s(length(s(y_0))))) (ACTIVE(U11(tt, zeros)) -> MARK(s(length(zeros))),ACTIVE(U11(tt, zeros)) -> MARK(s(length(zeros)))) (ACTIVE(U11(tt, U11(y_0, y_1))) -> MARK(s(length(U11(y_0, y_1)))),ACTIVE(U11(tt, U11(y_0, y_1))) -> MARK(s(length(U11(y_0, y_1))))) (ACTIVE(U11(tt, and(y_0, y_1))) -> MARK(s(length(and(y_0, y_1)))),ACTIVE(U11(tt, and(y_0, y_1))) -> MARK(s(length(and(y_0, y_1))))) (ACTIVE(U11(tt, length(y_0))) -> MARK(s(length(length(y_0)))),ACTIVE(U11(tt, length(y_0))) -> MARK(s(length(length(y_0))))) (ACTIVE(U11(tt, isNatList(y_0))) -> MARK(s(length(isNatList(y_0)))),ACTIVE(U11(tt, isNatList(y_0))) -> MARK(s(length(isNatList(y_0))))) (ACTIVE(U11(tt, isNatIList(y_0))) -> MARK(s(length(isNatIList(y_0)))),ACTIVE(U11(tt, isNatIList(y_0))) -> MARK(s(length(isNatIList(y_0))))) (ACTIVE(U11(tt, isNat(y_0))) -> MARK(s(length(isNat(y_0)))),ACTIVE(U11(tt, isNat(y_0))) -> MARK(s(length(isNat(y_0))))) ---------------------------------------- (143) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(s(length(cons(y_0, y_1)))) -> MARK(length(cons(y_0, y_1))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(s(length(s(y_0)))) -> MARK(length(s(y_0))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(s(length(zeros))) -> MARK(length(zeros)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(s(length(U11(y_0, y_1)))) -> MARK(length(U11(y_0, y_1))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(s(length(and(y_0, y_1)))) -> MARK(length(and(y_0, y_1))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(s(length(length(y_0)))) -> MARK(length(length(y_0))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(s(length(isNatList(y_0)))) -> MARK(length(isNatList(y_0))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(s(length(isNatIList(y_0)))) -> MARK(length(isNatIList(y_0))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(s(length(isNat(y_0)))) -> MARK(length(isNat(y_0))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(active(and(mark(isNatList(z1)), isNat(z0))), z1)) MARK(length(cons(y_0, y_1))) -> ACTIVE(length(cons(y_0, y_1))) ACTIVE(U11(tt, cons(y_0, y_1))) -> MARK(s(length(cons(y_0, y_1)))) ACTIVE(U11(tt, s(y_0))) -> MARK(s(length(s(y_0)))) ACTIVE(U11(tt, zeros)) -> MARK(s(length(zeros))) ACTIVE(U11(tt, U11(y_0, y_1))) -> MARK(s(length(U11(y_0, y_1)))) ACTIVE(U11(tt, and(y_0, y_1))) -> MARK(s(length(and(y_0, y_1)))) ACTIVE(U11(tt, length(y_0))) -> MARK(s(length(length(y_0)))) ACTIVE(U11(tt, isNatList(y_0))) -> MARK(s(length(isNatList(y_0)))) ACTIVE(U11(tt, isNatIList(y_0))) -> MARK(s(length(isNatIList(y_0)))) ACTIVE(U11(tt, isNat(y_0))) -> MARK(s(length(isNat(y_0)))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (144) 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(length(isNat(y_0)))) -> MARK(length(isNat(y_0))) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVE(x_1)) = 2*x_1 POL(MARK(x_1)) = 2*x_1 POL(U11(x_1, x_2)) = 2*x_2 POL(active(x_1)) = x_1 POL(and(x_1, x_2)) = 2*x_2 POL(cons(x_1, x_2)) = 2*x_2 POL(isNat(x_1)) = 2 POL(isNatIList(x_1)) = 0 POL(isNatList(x_1)) = 0 POL(length(x_1)) = x_1 POL(mark(x_1)) = x_1 POL(nil) = 0 POL(s(x_1)) = 2*x_1 POL(tt) = 0 POL(zeros) = 0 ---------------------------------------- (145) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(s(length(cons(y_0, y_1)))) -> MARK(length(cons(y_0, y_1))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) MARK(s(length(s(y_0)))) -> MARK(length(s(y_0))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) MARK(s(length(zeros))) -> MARK(length(zeros)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(s(length(U11(y_0, y_1)))) -> MARK(length(U11(y_0, y_1))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) MARK(s(length(and(y_0, y_1)))) -> MARK(length(and(y_0, y_1))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(s(length(length(y_0)))) -> MARK(length(length(y_0))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(s(length(isNatList(y_0)))) -> MARK(length(isNatList(y_0))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(s(length(isNatIList(y_0)))) -> MARK(length(isNatIList(y_0))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(length(isNat(x0))) -> ACTIVE(length(active(isNat(x0)))) MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(active(and(mark(isNatList(z1)), isNat(z0))), z1)) MARK(length(cons(y_0, y_1))) -> ACTIVE(length(cons(y_0, y_1))) ACTIVE(U11(tt, cons(y_0, y_1))) -> MARK(s(length(cons(y_0, y_1)))) ACTIVE(U11(tt, s(y_0))) -> MARK(s(length(s(y_0)))) ACTIVE(U11(tt, zeros)) -> MARK(s(length(zeros))) ACTIVE(U11(tt, U11(y_0, y_1))) -> MARK(s(length(U11(y_0, y_1)))) ACTIVE(U11(tt, and(y_0, y_1))) -> MARK(s(length(and(y_0, y_1)))) ACTIVE(U11(tt, length(y_0))) -> MARK(s(length(length(y_0)))) ACTIVE(U11(tt, isNatList(y_0))) -> MARK(s(length(isNatList(y_0)))) ACTIVE(U11(tt, isNatIList(y_0))) -> MARK(s(length(isNatIList(y_0)))) ACTIVE(U11(tt, isNat(y_0))) -> MARK(s(length(isNat(y_0)))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (146) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes. ---------------------------------------- (147) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(active(and(mark(isNatList(z1)), isNat(z0))), z1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) ACTIVE(U11(tt, cons(y_0, y_1))) -> MARK(s(length(cons(y_0, y_1)))) MARK(s(length(cons(y_0, y_1)))) -> MARK(length(cons(y_0, y_1))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) ACTIVE(U11(tt, s(y_0))) -> MARK(s(length(s(y_0)))) MARK(s(length(s(y_0)))) -> MARK(length(s(y_0))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) ACTIVE(U11(tt, zeros)) -> MARK(s(length(zeros))) MARK(s(length(zeros))) -> MARK(length(zeros)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) ACTIVE(U11(tt, U11(y_0, y_1))) -> MARK(s(length(U11(y_0, y_1)))) MARK(s(length(U11(y_0, y_1)))) -> MARK(length(U11(y_0, y_1))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) ACTIVE(U11(tt, and(y_0, y_1))) -> MARK(s(length(and(y_0, y_1)))) MARK(s(length(and(y_0, y_1)))) -> MARK(length(and(y_0, y_1))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) ACTIVE(U11(tt, length(y_0))) -> MARK(s(length(length(y_0)))) MARK(s(length(length(y_0)))) -> MARK(length(length(y_0))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) ACTIVE(U11(tt, isNatList(y_0))) -> MARK(s(length(isNatList(y_0)))) MARK(s(length(isNatList(y_0)))) -> MARK(length(isNatList(y_0))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) ACTIVE(U11(tt, isNatIList(y_0))) -> MARK(s(length(isNatIList(y_0)))) MARK(s(length(isNatIList(y_0)))) -> MARK(length(isNatIList(y_0))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(length(cons(y_0, y_1))) -> ACTIVE(length(cons(y_0, y_1))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (148) 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(length(isNatIList(y_0)))) -> MARK(length(isNatIList(y_0))) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVE(x_1)) = 2*x_1 POL(MARK(x_1)) = 2*x_1 POL(U11(x_1, x_2)) = 2*x_2 POL(active(x_1)) = x_1 POL(and(x_1, x_2)) = x_2 POL(cons(x_1, x_2)) = 2*x_2 POL(isNat(x_1)) = 0 POL(isNatIList(x_1)) = 2 POL(isNatList(x_1)) = 0 POL(length(x_1)) = x_1 POL(mark(x_1)) = x_1 POL(nil) = 0 POL(s(x_1)) = 2*x_1 POL(tt) = 0 POL(zeros) = 0 ---------------------------------------- (149) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(active(and(mark(isNatList(z1)), isNat(z0))), z1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) ACTIVE(U11(tt, cons(y_0, y_1))) -> MARK(s(length(cons(y_0, y_1)))) MARK(s(length(cons(y_0, y_1)))) -> MARK(length(cons(y_0, y_1))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) ACTIVE(U11(tt, s(y_0))) -> MARK(s(length(s(y_0)))) MARK(s(length(s(y_0)))) -> MARK(length(s(y_0))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) ACTIVE(U11(tt, zeros)) -> MARK(s(length(zeros))) MARK(s(length(zeros))) -> MARK(length(zeros)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) ACTIVE(U11(tt, U11(y_0, y_1))) -> MARK(s(length(U11(y_0, y_1)))) MARK(s(length(U11(y_0, y_1)))) -> MARK(length(U11(y_0, y_1))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) ACTIVE(U11(tt, and(y_0, y_1))) -> MARK(s(length(and(y_0, y_1)))) MARK(s(length(and(y_0, y_1)))) -> MARK(length(and(y_0, y_1))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) ACTIVE(U11(tt, length(y_0))) -> MARK(s(length(length(y_0)))) MARK(s(length(length(y_0)))) -> MARK(length(length(y_0))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) ACTIVE(U11(tt, isNatList(y_0))) -> MARK(s(length(isNatList(y_0)))) MARK(s(length(isNatList(y_0)))) -> MARK(length(isNatList(y_0))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) ACTIVE(U11(tt, isNatIList(y_0))) -> MARK(s(length(isNatIList(y_0)))) MARK(length(isNatIList(x0))) -> ACTIVE(length(active(isNatIList(x0)))) MARK(length(cons(y_0, y_1))) -> ACTIVE(length(cons(y_0, y_1))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (150) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes. ---------------------------------------- (151) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(active(and(mark(isNatList(z1)), isNat(z0))), z1)) ACTIVE(U11(tt, cons(y_0, y_1))) -> MARK(s(length(cons(y_0, y_1)))) MARK(s(length(cons(y_0, y_1)))) -> MARK(length(cons(y_0, y_1))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) ACTIVE(U11(tt, s(y_0))) -> MARK(s(length(s(y_0)))) MARK(s(length(s(y_0)))) -> MARK(length(s(y_0))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) ACTIVE(U11(tt, zeros)) -> MARK(s(length(zeros))) MARK(s(length(zeros))) -> MARK(length(zeros)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) ACTIVE(U11(tt, U11(y_0, y_1))) -> MARK(s(length(U11(y_0, y_1)))) MARK(s(length(U11(y_0, y_1)))) -> MARK(length(U11(y_0, y_1))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) ACTIVE(U11(tt, and(y_0, y_1))) -> MARK(s(length(and(y_0, y_1)))) MARK(s(length(and(y_0, y_1)))) -> MARK(length(and(y_0, y_1))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) ACTIVE(U11(tt, length(y_0))) -> MARK(s(length(length(y_0)))) MARK(s(length(length(y_0)))) -> MARK(length(length(y_0))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) ACTIVE(U11(tt, isNatList(y_0))) -> MARK(s(length(isNatList(y_0)))) MARK(s(length(isNatList(y_0)))) -> MARK(length(isNatList(y_0))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(cons(y_0, y_1))) -> ACTIVE(length(cons(y_0, y_1))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (152) 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(length(isNatList(y_0)))) -> MARK(length(isNatList(y_0))) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVE(x_1)) = 2*x_1 POL(MARK(x_1)) = 2*x_1 POL(U11(x_1, x_2)) = 2*x_2 POL(active(x_1)) = x_1 POL(and(x_1, x_2)) = x_2 POL(cons(x_1, x_2)) = 2*x_2 POL(isNat(x_1)) = 2 POL(isNatIList(x_1)) = 0 POL(isNatList(x_1)) = 2 POL(length(x_1)) = x_1 POL(mark(x_1)) = x_1 POL(nil) = 0 POL(s(x_1)) = 2*x_1 POL(tt) = 0 POL(zeros) = 0 ---------------------------------------- (153) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(active(and(mark(isNatList(z1)), isNat(z0))), z1)) ACTIVE(U11(tt, cons(y_0, y_1))) -> MARK(s(length(cons(y_0, y_1)))) MARK(s(length(cons(y_0, y_1)))) -> MARK(length(cons(y_0, y_1))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) ACTIVE(U11(tt, s(y_0))) -> MARK(s(length(s(y_0)))) MARK(s(length(s(y_0)))) -> MARK(length(s(y_0))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) ACTIVE(U11(tt, zeros)) -> MARK(s(length(zeros))) MARK(s(length(zeros))) -> MARK(length(zeros)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) ACTIVE(U11(tt, U11(y_0, y_1))) -> MARK(s(length(U11(y_0, y_1)))) MARK(s(length(U11(y_0, y_1)))) -> MARK(length(U11(y_0, y_1))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) ACTIVE(U11(tt, and(y_0, y_1))) -> MARK(s(length(and(y_0, y_1)))) MARK(s(length(and(y_0, y_1)))) -> MARK(length(and(y_0, y_1))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) ACTIVE(U11(tt, length(y_0))) -> MARK(s(length(length(y_0)))) MARK(s(length(length(y_0)))) -> MARK(length(length(y_0))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) ACTIVE(U11(tt, isNatList(y_0))) -> MARK(s(length(isNatList(y_0)))) MARK(length(isNatList(x0))) -> ACTIVE(length(active(isNatList(x0)))) MARK(length(cons(y_0, y_1))) -> ACTIVE(length(cons(y_0, y_1))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (154) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes. ---------------------------------------- (155) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(active(and(mark(isNatList(z1)), isNat(z0))), z1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) ACTIVE(U11(tt, cons(y_0, y_1))) -> MARK(s(length(cons(y_0, y_1)))) MARK(s(length(cons(y_0, y_1)))) -> MARK(length(cons(y_0, y_1))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) ACTIVE(U11(tt, s(y_0))) -> MARK(s(length(s(y_0)))) MARK(s(length(s(y_0)))) -> MARK(length(s(y_0))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) ACTIVE(U11(tt, zeros)) -> MARK(s(length(zeros))) MARK(s(length(zeros))) -> MARK(length(zeros)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) ACTIVE(U11(tt, U11(y_0, y_1))) -> MARK(s(length(U11(y_0, y_1)))) MARK(s(length(U11(y_0, y_1)))) -> MARK(length(U11(y_0, y_1))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) ACTIVE(U11(tt, and(y_0, y_1))) -> MARK(s(length(and(y_0, y_1)))) MARK(s(length(and(y_0, y_1)))) -> MARK(length(and(y_0, y_1))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) ACTIVE(U11(tt, length(y_0))) -> MARK(s(length(length(y_0)))) MARK(s(length(length(y_0)))) -> MARK(length(length(y_0))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(cons(y_0, y_1))) -> ACTIVE(length(cons(y_0, y_1))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (156) 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(U11(tt, U11(y_0, y_1))) -> MARK(s(length(U11(y_0, y_1)))) ACTIVE(U11(tt, length(y_0))) -> MARK(s(length(length(y_0)))) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVE(x_1)) = 2*x_1 POL(MARK(x_1)) = 2*x_1 POL(U11(x_1, x_2)) = 1 + 2*x_2 POL(active(x_1)) = x_1 POL(and(x_1, x_2)) = 2*x_2 POL(cons(x_1, x_2)) = 2*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(tt) = 0 POL(zeros) = 0 ---------------------------------------- (157) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(active(and(mark(isNatList(z1)), isNat(z0))), z1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) ACTIVE(U11(tt, cons(y_0, y_1))) -> MARK(s(length(cons(y_0, y_1)))) MARK(s(length(cons(y_0, y_1)))) -> MARK(length(cons(y_0, y_1))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) ACTIVE(U11(tt, s(y_0))) -> MARK(s(length(s(y_0)))) MARK(s(length(s(y_0)))) -> MARK(length(s(y_0))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) ACTIVE(U11(tt, zeros)) -> MARK(s(length(zeros))) MARK(s(length(zeros))) -> MARK(length(zeros)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(s(length(U11(y_0, y_1)))) -> MARK(length(U11(y_0, y_1))) MARK(length(U11(x0, x1))) -> ACTIVE(length(active(U11(mark(x0), x1)))) ACTIVE(U11(tt, and(y_0, y_1))) -> MARK(s(length(and(y_0, y_1)))) MARK(s(length(and(y_0, y_1)))) -> MARK(length(and(y_0, y_1))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(s(length(length(y_0)))) -> MARK(length(length(y_0))) MARK(length(length(x0))) -> ACTIVE(length(active(length(mark(x0))))) MARK(length(cons(y_0, y_1))) -> ACTIVE(length(cons(y_0, y_1))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (158) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 4 less nodes. ---------------------------------------- (159) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(active(and(mark(isNatList(z1)), isNat(z0))), z1)) ACTIVE(U11(tt, cons(y_0, y_1))) -> MARK(s(length(cons(y_0, y_1)))) MARK(s(length(cons(y_0, y_1)))) -> MARK(length(cons(y_0, y_1))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) ACTIVE(U11(tt, s(y_0))) -> MARK(s(length(s(y_0)))) MARK(s(length(s(y_0)))) -> MARK(length(s(y_0))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) ACTIVE(U11(tt, zeros)) -> MARK(s(length(zeros))) MARK(s(length(zeros))) -> MARK(length(zeros)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) ACTIVE(U11(tt, and(y_0, y_1))) -> MARK(s(length(and(y_0, y_1)))) MARK(s(length(and(y_0, y_1)))) -> MARK(length(and(y_0, y_1))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(cons(y_0, y_1))) -> ACTIVE(length(cons(y_0, y_1))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (160) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. ACTIVE(U11(tt, cons(y_0, y_1))) -> MARK(s(length(cons(y_0, y_1)))) The remaining pairs can at least be oriented weakly. Used ordering: Matrix interpretation [MATRO] with arctic natural numbers [ARCTIC]: <<< POL(ACTIVE(x_1)) = [[0A]] + [[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(MARK(x_1)) = [[1A]] + [[0A]] * x_1 >>> <<< POL(U11(x_1, x_2)) = [[-I]] + [[-I]] * x_1 + [[1A]] * x_2 >>> <<< POL(and(x_1, x_2)) = [[0A]] + [[0A]] * x_1 + [[0A]] * x_2 >>> <<< POL(isNatList(x_1)) = [[0A]] + [[0A]] * x_1 >>> <<< POL(isNat(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(active(x_1)) = [[1A]] + [[0A]] * x_1 >>> <<< POL(mark(x_1)) = [[1A]] + [[0A]] * x_1 >>> <<< POL(tt) = [[0A]] >>> <<< POL(s(x_1)) = [[0A]] + [[0A]] * x_1 >>> <<< POL(zeros) = [[0A]] >>> <<< POL(0) = [[0A]] >>> <<< POL(isNatIList(x_1)) = [[0A]] + [[0A]] * x_1 >>> <<< POL(nil) = [[0A]] >>> The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) mark(0) -> active(0) mark(tt) -> active(tt) mark(nil) -> active(nil) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) s(active(X)) -> s(X) s(mark(X)) -> s(X) ---------------------------------------- (161) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(active(and(mark(isNatList(z1)), isNat(z0))), z1)) MARK(s(length(cons(y_0, y_1)))) -> MARK(length(cons(y_0, y_1))) MARK(length(cons(x0, x1))) -> ACTIVE(length(active(cons(mark(x0), x1)))) ACTIVE(U11(tt, s(y_0))) -> MARK(s(length(s(y_0)))) MARK(s(length(s(y_0)))) -> MARK(length(s(y_0))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) ACTIVE(U11(tt, zeros)) -> MARK(s(length(zeros))) MARK(s(length(zeros))) -> MARK(length(zeros)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) ACTIVE(U11(tt, and(y_0, y_1))) -> MARK(s(length(and(y_0, y_1)))) MARK(s(length(and(y_0, y_1)))) -> MARK(length(and(y_0, y_1))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) MARK(length(cons(y_0, y_1))) -> ACTIVE(length(cons(y_0, y_1))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (162) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 3 less nodes. ---------------------------------------- (163) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(active(and(mark(isNatList(z1)), isNat(z0))), z1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) ACTIVE(U11(tt, s(y_0))) -> MARK(s(length(s(y_0)))) MARK(s(length(s(y_0)))) -> MARK(length(s(y_0))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) ACTIVE(U11(tt, zeros)) -> MARK(s(length(zeros))) MARK(s(length(zeros))) -> MARK(length(zeros)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) ACTIVE(U11(tt, and(y_0, y_1))) -> MARK(s(length(and(y_0, y_1)))) MARK(s(length(and(y_0, y_1)))) -> MARK(length(and(y_0, y_1))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (164) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. ACTIVE(U11(tt, and(y_0, y_1))) -> MARK(s(length(and(y_0, y_1)))) 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(U11(x_1, x_2)) = [[-I]] + [[-I]] * x_1 + [[1A]] * x_2 >>> <<< POL(and(x_1, x_2)) = [[1A]] + [[0A]] * x_1 + [[0A]] * x_2 >>> <<< POL(isNatList(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(isNat(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(ACTIVE(x_1)) = [[0A]] + [[0A]] * x_1 >>> <<< POL(active(x_1)) = [[1A]] + [[0A]] * x_1 >>> <<< POL(mark(x_1)) = [[1A]] + [[0A]] * x_1 >>> <<< POL(length(x_1)) = [[0A]] + [[0A]] * x_1 >>> <<< POL(cons(x_1, x_2)) = [[1A]] + [[0A]] * x_1 + [[1A]] * x_2 >>> <<< POL(tt) = [[0A]] >>> <<< POL(s(x_1)) = [[0A]] + [[0A]] * x_1 >>> <<< POL(zeros) = [[0A]] >>> <<< POL(0) = [[0A]] >>> <<< POL(isNatIList(x_1)) = [[0A]] + [[0A]] * x_1 >>> <<< POL(nil) = [[0A]] >>> The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) and(X1, mark(X2)) -> and(X1, X2) and(mark(X1), X2) -> and(X1, X2) and(active(X1), X2) -> and(X1, X2) and(X1, active(X2)) -> and(X1, X2) active(isNat(0)) -> mark(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) mark(0) -> active(0) mark(tt) -> active(tt) mark(nil) -> active(nil) s(active(X)) -> s(X) s(mark(X)) -> s(X) length(active(X)) -> length(X) length(mark(X)) -> length(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) ---------------------------------------- (165) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(active(and(mark(isNatList(z1)), isNat(z0))), z1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) ACTIVE(U11(tt, s(y_0))) -> MARK(s(length(s(y_0)))) MARK(s(length(s(y_0)))) -> MARK(length(s(y_0))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) ACTIVE(U11(tt, zeros)) -> MARK(s(length(zeros))) MARK(s(length(zeros))) -> MARK(length(zeros)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) MARK(s(length(and(y_0, y_1)))) -> MARK(length(and(y_0, y_1))) MARK(length(and(x0, x1))) -> ACTIVE(length(active(and(mark(x0), x1)))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (166) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes. ---------------------------------------- (167) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(active(and(mark(isNatList(z1)), isNat(z0))), z1)) ACTIVE(U11(tt, s(y_0))) -> MARK(s(length(s(y_0)))) MARK(s(length(s(y_0)))) -> MARK(length(s(y_0))) MARK(length(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) ACTIVE(U11(tt, zeros)) -> MARK(s(length(zeros))) MARK(s(length(zeros))) -> MARK(length(zeros)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (168) 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(s(x0))) -> ACTIVE(length(active(s(mark(x0))))) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVE(x_1)) = x_1 POL(MARK(x_1)) = 2 POL(U11(x_1, x_2)) = 2 POL(active(x_1)) = x_1 POL(and(x_1, x_2)) = x_2 POL(cons(x_1, x_2)) = 1 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)) = 0 POL(tt) = 0 POL(zeros) = 1 ---------------------------------------- (169) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(active(and(mark(isNatList(z1)), isNat(z0))), z1)) ACTIVE(U11(tt, s(y_0))) -> MARK(s(length(s(y_0)))) MARK(s(length(s(y_0)))) -> MARK(length(s(y_0))) ACTIVE(U11(tt, zeros)) -> MARK(s(length(zeros))) MARK(s(length(zeros))) -> MARK(length(zeros)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (170) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes. ---------------------------------------- (171) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(active(and(mark(isNatList(z1)), isNat(z0))), z1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) ACTIVE(U11(tt, zeros)) -> MARK(s(length(zeros))) MARK(s(length(zeros))) -> MARK(length(zeros)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (172) NonMonReductionPairProof (EQUIVALENT) Using the following max-polynomial ordering, we can orient the general usable rules and all rules from P weakly and some rules from P strictly: Polynomial interpretation with max [POLO,NEGPOLO,MAXPOLO]: POL(0) = 0 POL(ACTIVE(x_1)) = x_1 POL(MARK(x_1)) = 0 POL(U11(x_1, x_2)) = max(0, 1 - x_1) POL(active(x_1)) = x_1 POL(and(x_1, x_2)) = max(0, x_1 + x_2) POL(cons(x_1, x_2)) = max(0, -x_1 - x_2) POL(isNat(x_1)) = 0 POL(isNatIList(x_1)) = 0 POL(isNatList(x_1)) = 1 POL(length(x_1)) = 0 POL(mark(x_1)) = x_1 POL(nil) = 0 POL(s(x_1)) = 1 POL(tt) = 0 POL(zeros) = 0 The following pairs can be oriented strictly and are deleted. ACTIVE(U11(tt, zeros)) -> MARK(s(length(zeros))) The remaining pairs can at least be oriented weakly. MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(active(and(mark(isNatList(z1)), isNat(z0))), z1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(s(length(zeros))) -> MARK(length(zeros)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) The following rules are usable: mark(cons(X1, X2)) <-> active(cons(mark(X1), X2)) mark(s(X)) <-> active(s(mark(X))) mark(zeros) <-> active(zeros) mark(U11(X1, X2)) <-> active(U11(mark(X1), X2)) mark(and(X1, X2)) <-> active(and(mark(X1), X2)) mark(length(X)) <-> active(length(mark(X))) mark(isNatList(X)) <-> active(isNatList(X)) mark(isNatIList(X)) <-> active(isNatIList(X)) mark(0) <-> active(0) mark(tt) <-> active(tt) mark(isNat(X)) <-> active(isNat(X)) mark(nil) <-> active(nil) active(zeros) <-> mark(cons(0, zeros)) active(U11(tt, L)) <-> mark(s(length(L))) active(and(tt, X)) <-> mark(X) active(isNatIList(cons(V1, V2))) <-> mark(and(isNat(V1), isNatIList(V2))) active(isNatList(cons(V1, V2))) <-> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) <-> mark(U11(and(isNatList(L), isNat(N)), L)) active(isNat(s(V1))) <-> mark(isNat(V1)) active(isNat(0)) <-> mark(tt) 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) cons(X1, mark(X2)) <-> cons(X1, X2) cons(mark(X1), X2) <-> cons(X1, X2) cons(active(X1), X2) <-> cons(X1, X2) cons(X1, active(X2)) <-> cons(X1, X2) s(active(X)) <-> s(X) s(mark(X)) <-> s(X) U11(X1, mark(X2)) <-> U11(X1, X2) U11(mark(X1), X2) <-> U11(X1, X2) U11(active(X1), X2) <-> U11(X1, X2) U11(X1, active(X2)) <-> U11(X1, X2) length(active(X)) <-> length(X) length(mark(X)) <-> length(X) ---------------------------------------- (173) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(active(and(mark(isNatList(z1)), isNat(z0))), z1)) ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(s(length(zeros))) -> MARK(length(zeros)) MARK(length(zeros)) -> ACTIVE(length(active(zeros))) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (174) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes. ---------------------------------------- (175) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(active(and(mark(isNatList(z1)), isNat(z0))), z1)) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (176) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. ACTIVE(length(cons(N, L))) -> MARK(U11(and(isNatList(L), isNat(N)), L)) MARK(U11(and(isNatList(z1), isNat(z0)), z1)) -> ACTIVE(U11(active(and(mark(isNatList(z1)), isNat(z0))), z1)) The remaining pairs can at least be oriented weakly. Used ordering: Combined order from the following AFS and order. ACTIVE(x1) = x1 length(x1) = length MARK(x1) = MARK U11(x1, x2) = U11 Knuth-Bendix order [KBO] with precedence:length > MARK > U11 and weight map: length=1 MARK=1 U11=1 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) ---------------------------------------- (177) Obligation: Q DP problem: P is empty. The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (178) PisEmptyProof (EQUIVALENT) The TRS P is empty. Hence, there is no (P,Q,R) chain. ---------------------------------------- (179) YES ---------------------------------------- (180) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(s(y_0))) -> MARK(s(y_0)) The TRS R consists of the following rules: mark(cons(X1, X2)) -> active(cons(mark(X1), X2)) active(zeros) -> mark(cons(0, zeros)) active(U11(tt, L)) -> mark(s(length(L))) mark(s(X)) -> active(s(mark(X))) active(and(tt, X)) -> mark(X) mark(zeros) -> active(zeros) mark(U11(X1, X2)) -> active(U11(mark(X1), X2)) active(isNatIList(cons(V1, V2))) -> mark(and(isNat(V1), isNatIList(V2))) mark(and(X1, X2)) -> active(and(mark(X1), X2)) active(isNatList(cons(V1, V2))) -> mark(and(isNat(V1), isNatList(V2))) active(length(cons(N, L))) -> mark(U11(and(isNatList(L), isNat(N)), L)) mark(length(X)) -> active(length(mark(X))) mark(isNatList(X)) -> active(isNatList(X)) mark(isNatIList(X)) -> active(isNatIList(X)) mark(0) -> active(0) mark(tt) -> active(tt) active(isNat(s(V1))) -> mark(isNat(V1)) mark(isNat(X)) -> active(isNat(X)) 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) active(isNat(0)) -> mark(tt) cons(X1, mark(X2)) -> cons(X1, X2) cons(mark(X1), X2) -> cons(X1, X2) cons(active(X1), X2) -> cons(X1, X2) cons(X1, active(X2)) -> cons(X1, X2) s(active(X)) -> s(X) s(mark(X)) -> s(X) U11(X1, mark(X2)) -> U11(X1, X2) U11(mark(X1), X2) -> U11(X1, X2) U11(active(X1), X2) -> U11(X1, X2) U11(X1, active(X2)) -> U11(X1, X2) length(active(X)) -> length(X) length(mark(X)) -> length(X) The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (181) 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. ---------------------------------------- (182) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(s(y_0))) -> MARK(s(y_0)) R is empty. The set Q consists of the following terms: active(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) s(mark(x0)) s(active(x0)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (183) 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(zeros) active(U11(tt, x0)) active(and(tt, x0)) active(isNat(0)) active(isNat(length(x0))) active(isNat(s(x0))) active(isNatIList(x0)) active(isNatList(nil)) active(isNatList(cons(x0, x1))) active(length(nil)) active(length(cons(x0, x1))) mark(zeros) mark(cons(x0, x1)) mark(0) mark(U11(x0, x1)) mark(tt) mark(s(x0)) mark(length(x0)) mark(and(x0, x1)) mark(isNat(x0)) mark(isNatList(x0)) mark(isNatIList(x0)) mark(nil) cons(mark(x0), x1) cons(x0, mark(x1)) cons(active(x0), x1) cons(x0, active(x1)) U11(mark(x0), x1) U11(x0, mark(x1)) U11(active(x0), x1) U11(x0, active(x1)) length(mark(x0)) length(active(x0)) and(mark(x0), x1) and(x0, mark(x1)) and(active(x0), x1) and(x0, active(x1)) isNat(mark(x0)) isNat(active(x0)) isNatList(mark(x0)) isNatList(active(x0)) isNatIList(mark(x0)) isNatIList(active(x0)) ---------------------------------------- (184) Obligation: Q DP problem: The TRS P consists of the following rules: MARK(s(s(y_0))) -> MARK(s(y_0)) R is empty. The set Q consists of the following terms: s(mark(x0)) s(active(x0)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (185) QDPSizeChangeProof (EQUIVALENT) By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. From the DPs we obtained the following set of size-change graphs: *MARK(s(s(y_0))) -> MARK(s(y_0)) The graph contains the following edges 1 > 1 ---------------------------------------- (186) YES