/export/starexec/sandbox/solver/bin/starexec_run_standard /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files -------------------------------------------------------------------------------- NO proof of /export/starexec/sandbox/benchmark/theBenchmark.xml # AProVE Commit ID: 48fb2092695e11cc9f56e44b17a92a5f88ffb256 marcel 20180622 unpublished dirty Termination w.r.t. Q of the given QTRS could be disproven: (0) QTRS (1) QTRSRRRProof [EQUIVALENT, 127 ms] (2) QTRS (3) QTRSRRRProof [EQUIVALENT, 28 ms] (4) QTRS (5) QTRSRRRProof [EQUIVALENT, 26 ms] (6) QTRS (7) QTRSRRRProof [EQUIVALENT, 34 ms] (8) QTRS (9) DependencyPairsProof [EQUIVALENT, 0 ms] (10) QDP (11) DependencyGraphProof [EQUIVALENT, 0 ms] (12) AND (13) QDP (14) UsableRulesReductionPairsProof [EQUIVALENT, 39 ms] (15) QDP (16) MRRProof [EQUIVALENT, 51 ms] (17) QDP (18) DependencyGraphProof [EQUIVALENT, 0 ms] (19) AND (20) QDP (21) QDPOrderProof [EQUIVALENT, 46 ms] (22) QDP (23) DependencyGraphProof [EQUIVALENT, 0 ms] (24) TRUE (25) QDP (26) UsableRulesProof [EQUIVALENT, 0 ms] (27) QDP (28) QDPSizeChangeProof [EQUIVALENT, 0 ms] (29) YES (30) QDP (31) QDPOrderProof [EQUIVALENT, 28 ms] (32) QDP (33) PisEmptyProof [EQUIVALENT, 0 ms] (34) YES (35) QDP (36) TransformationProof [EQUIVALENT, 0 ms] (37) QDP (38) TransformationProof [EQUIVALENT, 0 ms] (39) QDP (40) TransformationProof [EQUIVALENT, 0 ms] (41) QDP (42) DependencyGraphProof [EQUIVALENT, 0 ms] (43) QDP (44) TransformationProof [EQUIVALENT, 0 ms] (45) QDP (46) DependencyGraphProof [EQUIVALENT, 0 ms] (47) QDP (48) TransformationProof [EQUIVALENT, 0 ms] (49) QDP (50) DependencyGraphProof [EQUIVALENT, 0 ms] (51) QDP (52) TransformationProof [EQUIVALENT, 0 ms] (53) QDP (54) TransformationProof [EQUIVALENT, 0 ms] (55) QDP (56) DependencyGraphProof [EQUIVALENT, 0 ms] (57) QDP (58) TransformationProof [EQUIVALENT, 0 ms] (59) QDP (60) DependencyGraphProof [EQUIVALENT, 0 ms] (61) QDP (62) TransformationProof [EQUIVALENT, 0 ms] (63) QDP (64) TransformationProof [EQUIVALENT, 0 ms] (65) QDP (66) DependencyGraphProof [EQUIVALENT, 0 ms] (67) QDP (68) TransformationProof [EQUIVALENT, 0 ms] (69) QDP (70) DependencyGraphProof [EQUIVALENT, 0 ms] (71) QDP (72) TransformationProof [EQUIVALENT, 0 ms] (73) QDP (74) MRRProof [EQUIVALENT, 27 ms] (75) QDP (76) MRRProof [EQUIVALENT, 15 ms] (77) QDP (78) QDPOrderProof [EQUIVALENT, 35 ms] (79) QDP (80) QDPOrderProof [EQUIVALENT, 51 ms] (81) QDP (82) QDPOrderProof [EQUIVALENT, 30 ms] (83) QDP (84) NonTerminationLoopProof [COMPLETE, 28 ms] (85) NO (86) QDP (87) UsableRulesReductionPairsProof [EQUIVALENT, 0 ms] (88) QDP (89) TransformationProof [EQUIVALENT, 0 ms] (90) QDP (91) TransformationProof [EQUIVALENT, 0 ms] (92) QDP (93) TransformationProof [EQUIVALENT, 1 ms] (94) QDP (95) DependencyGraphProof [EQUIVALENT, 0 ms] (96) QDP (97) TransformationProof [EQUIVALENT, 0 ms] (98) QDP (99) DependencyGraphProof [EQUIVALENT, 0 ms] (100) QDP (101) TransformationProof [EQUIVALENT, 0 ms] (102) QDP (103) TransformationProof [EQUIVALENT, 0 ms] (104) QDP (105) DependencyGraphProof [EQUIVALENT, 0 ms] (106) QDP (107) TransformationProof [EQUIVALENT, 0 ms] (108) QDP (109) DependencyGraphProof [EQUIVALENT, 0 ms] (110) QDP (111) TransformationProof [EQUIVALENT, 0 ms] (112) QDP (113) DependencyGraphProof [EQUIVALENT, 0 ms] (114) QDP (115) TransformationProof [EQUIVALENT, 0 ms] (116) QDP (117) TransformationProof [EQUIVALENT, 18 ms] (118) QDP (119) DependencyGraphProof [EQUIVALENT, 0 ms] (120) QDP (121) TransformationProof [EQUIVALENT, 0 ms] (122) QDP (123) DependencyGraphProof [EQUIVALENT, 0 ms] (124) QDP (125) TransformationProof [EQUIVALENT, 0 ms] (126) QDP (127) MRRProof [EQUIVALENT, 18 ms] (128) QDP (129) MRRProof [EQUIVALENT, 49 ms] (130) QDP (131) QDPOrderProof [EQUIVALENT, 39 ms] (132) QDP (133) QDPOrderProof [EQUIVALENT, 33 ms] (134) QDP (135) QDPOrderProof [EQUIVALENT, 19 ms] (136) QDP (137) NonTerminationLoopProof [COMPLETE, 0 ms] (138) NO ---------------------------------------- (0) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: zeros -> cons(0, n__zeros) U11(tt) -> tt U21(tt) -> tt U31(tt) -> tt U41(tt, V2) -> U42(isNatIList(activate(V2))) U42(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) isNat(n__0) -> tt isNat(n__length(V1)) -> U11(isNatList(activate(V1))) isNat(n__s(V1)) -> U21(isNat(activate(V1))) isNatIList(V) -> U31(isNatList(activate(V))) isNatIList(n__zeros) -> tt isNatIList(n__cons(V1, V2)) -> U41(isNat(activate(V1)), activate(V2)) isNatList(n__nil) -> tt isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) length(nil) -> 0 length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) zeros -> n__zeros 0 -> n__0 length(X) -> n__length(X) s(X) -> n__s(X) cons(X1, X2) -> n__cons(X1, X2) nil -> n__nil activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X Q is empty. ---------------------------------------- (1) QTRSRRRProof (EQUIVALENT) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(U11(x_1)) = x_1 POL(U21(x_1)) = x_1 POL(U31(x_1)) = x_1 POL(U41(x_1, x_2)) = x_1 + 2*x_2 POL(U42(x_1)) = 2*x_1 POL(U51(x_1, x_2)) = x_1 + 2*x_2 POL(U52(x_1)) = 2*x_1 POL(U61(x_1, x_2, x_3)) = x_1 + x_2 + 2*x_3 POL(U62(x_1, x_2)) = x_1 + x_2 POL(activate(x_1)) = x_1 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)) = x_1 POL(n__0) = 0 POL(n__cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(n__length(x_1)) = x_1 POL(n__nil) = 1 POL(n__s(x_1)) = x_1 POL(n__zeros) = 0 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: isNatList(n__nil) -> tt length(nil) -> 0 ---------------------------------------- (2) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: zeros -> cons(0, n__zeros) U11(tt) -> tt U21(tt) -> tt U31(tt) -> tt U41(tt, V2) -> U42(isNatIList(activate(V2))) U42(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) isNat(n__0) -> tt isNat(n__length(V1)) -> U11(isNatList(activate(V1))) isNat(n__s(V1)) -> U21(isNat(activate(V1))) isNatIList(V) -> U31(isNatList(activate(V))) isNatIList(n__zeros) -> tt isNatIList(n__cons(V1, V2)) -> U41(isNat(activate(V1)), activate(V2)) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) zeros -> n__zeros 0 -> n__0 length(X) -> n__length(X) s(X) -> n__s(X) cons(X1, X2) -> n__cons(X1, X2) nil -> n__nil activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X Q is empty. ---------------------------------------- (3) QTRSRRRProof (EQUIVALENT) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(U11(x_1)) = 1 + 2*x_1 POL(U21(x_1)) = x_1 POL(U31(x_1)) = x_1 POL(U41(x_1, x_2)) = x_1 + 2*x_2 POL(U42(x_1)) = 2*x_1 POL(U51(x_1, x_2)) = x_1 + x_2 POL(U52(x_1)) = x_1 POL(U61(x_1, x_2, x_3)) = 1 + x_1 + 2*x_2 + 2*x_3 POL(U62(x_1, x_2)) = 1 + x_1 + 2*x_2 POL(activate(x_1)) = x_1 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)) = 1 + 2*x_1 POL(n__0) = 0 POL(n__cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(n__length(x_1)) = 1 + 2*x_1 POL(n__nil) = 0 POL(n__s(x_1)) = x_1 POL(n__zeros) = 0 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: U11(tt) -> tt isNat(n__length(V1)) -> U11(isNatList(activate(V1))) ---------------------------------------- (4) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: zeros -> cons(0, n__zeros) U21(tt) -> tt U31(tt) -> tt U41(tt, V2) -> U42(isNatIList(activate(V2))) U42(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) isNatIList(V) -> U31(isNatList(activate(V))) isNatIList(n__zeros) -> tt isNatIList(n__cons(V1, V2)) -> U41(isNat(activate(V1)), activate(V2)) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) zeros -> n__zeros 0 -> n__0 length(X) -> n__length(X) s(X) -> n__s(X) cons(X1, X2) -> n__cons(X1, X2) nil -> n__nil activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X Q is empty. ---------------------------------------- (5) QTRSRRRProof (EQUIVALENT) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(U21(x_1)) = x_1 POL(U31(x_1)) = x_1 POL(U41(x_1, x_2)) = 1 + 2*x_1 + x_2 POL(U42(x_1)) = x_1 POL(U51(x_1, x_2)) = x_1 + x_2 POL(U52(x_1)) = x_1 POL(U61(x_1, x_2, x_3)) = 2*x_1 + 2*x_2 + 2*x_3 POL(U62(x_1, x_2)) = x_1 + 2*x_2 POL(activate(x_1)) = x_1 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(n__0) = 0 POL(n__cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(n__length(x_1)) = 2*x_1 POL(n__nil) = 0 POL(n__s(x_1)) = x_1 POL(n__zeros) = 0 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: isNatIList(V) -> U31(isNatList(activate(V))) isNatIList(n__zeros) -> tt ---------------------------------------- (6) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: zeros -> cons(0, n__zeros) U21(tt) -> tt U31(tt) -> tt U41(tt, V2) -> U42(isNatIList(activate(V2))) U42(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) isNatIList(n__cons(V1, V2)) -> U41(isNat(activate(V1)), activate(V2)) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) zeros -> n__zeros 0 -> n__0 length(X) -> n__length(X) s(X) -> n__s(X) cons(X1, X2) -> n__cons(X1, X2) nil -> n__nil activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X Q is empty. ---------------------------------------- (7) QTRSRRRProof (EQUIVALENT) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(U21(x_1)) = x_1 POL(U31(x_1)) = 1 + x_1 POL(U41(x_1, x_2)) = 2*x_1 + 2*x_2 POL(U42(x_1)) = 2*x_1 POL(U51(x_1, x_2)) = 2*x_1 + x_2 POL(U52(x_1)) = x_1 POL(U61(x_1, x_2, x_3)) = 2*x_1 + 2*x_2 + 2*x_3 POL(U62(x_1, x_2)) = x_1 + 2*x_2 POL(activate(x_1)) = x_1 POL(cons(x_1, x_2)) = 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)) = 2*x_1 POL(n__0) = 0 POL(n__cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(n__length(x_1)) = 2*x_1 POL(n__nil) = 0 POL(n__s(x_1)) = x_1 POL(n__zeros) = 0 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: U31(tt) -> tt ---------------------------------------- (8) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: zeros -> cons(0, n__zeros) U21(tt) -> tt U41(tt, V2) -> U42(isNatIList(activate(V2))) U42(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) isNatIList(n__cons(V1, V2)) -> U41(isNat(activate(V1)), activate(V2)) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) zeros -> n__zeros 0 -> n__0 length(X) -> n__length(X) s(X) -> n__s(X) cons(X1, X2) -> n__cons(X1, X2) nil -> n__nil activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X Q is empty. ---------------------------------------- (9) DependencyPairsProof (EQUIVALENT) Using Dependency Pairs [AG00,LPAR04] we result in the following initial DP problem. ---------------------------------------- (10) Obligation: Q DP problem: The TRS P consists of the following rules: ZEROS -> CONS(0, n__zeros) ZEROS -> 0^1 U41^1(tt, V2) -> U42^1(isNatIList(activate(V2))) U41^1(tt, V2) -> ISNATILIST(activate(V2)) U41^1(tt, V2) -> ACTIVATE(V2) U51^1(tt, V2) -> U52^1(isNatList(activate(V2))) U51^1(tt, V2) -> ISNATLIST(activate(V2)) U51^1(tt, V2) -> ACTIVATE(V2) U61^1(tt, L, N) -> U62^1(isNat(activate(N)), activate(L)) U61^1(tt, L, N) -> ISNAT(activate(N)) U61^1(tt, L, N) -> ACTIVATE(N) U61^1(tt, L, N) -> ACTIVATE(L) U62^1(tt, L) -> S(length(activate(L))) U62^1(tt, L) -> LENGTH(activate(L)) U62^1(tt, L) -> ACTIVATE(L) ISNAT(n__s(V1)) -> U21^1(isNat(activate(V1))) ISNAT(n__s(V1)) -> ISNAT(activate(V1)) ISNAT(n__s(V1)) -> ACTIVATE(V1) ISNATILIST(n__cons(V1, V2)) -> U41^1(isNat(activate(V1)), activate(V2)) ISNATILIST(n__cons(V1, V2)) -> ISNAT(activate(V1)) ISNATILIST(n__cons(V1, V2)) -> ACTIVATE(V1) ISNATILIST(n__cons(V1, V2)) -> ACTIVATE(V2) ISNATLIST(n__cons(V1, V2)) -> U51^1(isNat(activate(V1)), activate(V2)) ISNATLIST(n__cons(V1, V2)) -> ISNAT(activate(V1)) ISNATLIST(n__cons(V1, V2)) -> ACTIVATE(V1) ISNATLIST(n__cons(V1, V2)) -> ACTIVATE(V2) LENGTH(cons(N, L)) -> U61^1(isNatList(activate(L)), activate(L), N) LENGTH(cons(N, L)) -> ISNATLIST(activate(L)) LENGTH(cons(N, L)) -> ACTIVATE(L) ACTIVATE(n__zeros) -> ZEROS ACTIVATE(n__0) -> 0^1 ACTIVATE(n__length(X)) -> LENGTH(activate(X)) ACTIVATE(n__length(X)) -> ACTIVATE(X) ACTIVATE(n__s(X)) -> S(activate(X)) ACTIVATE(n__s(X)) -> ACTIVATE(X) ACTIVATE(n__cons(X1, X2)) -> CONS(activate(X1), X2) ACTIVATE(n__cons(X1, X2)) -> ACTIVATE(X1) ACTIVATE(n__nil) -> NIL The TRS R consists of the following rules: zeros -> cons(0, n__zeros) U21(tt) -> tt U41(tt, V2) -> U42(isNatIList(activate(V2))) U42(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) isNatIList(n__cons(V1, V2)) -> U41(isNat(activate(V1)), activate(V2)) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) zeros -> n__zeros 0 -> n__0 length(X) -> n__length(X) s(X) -> n__s(X) cons(X1, X2) -> n__cons(X1, X2) nil -> n__nil activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (11) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 2 SCCs with 15 less nodes. ---------------------------------------- (12) Complex Obligation (AND) ---------------------------------------- (13) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVATE(n__length(X)) -> LENGTH(activate(X)) LENGTH(cons(N, L)) -> U61^1(isNatList(activate(L)), activate(L), N) U61^1(tt, L, N) -> U62^1(isNat(activate(N)), activate(L)) U62^1(tt, L) -> LENGTH(activate(L)) LENGTH(cons(N, L)) -> ISNATLIST(activate(L)) ISNATLIST(n__cons(V1, V2)) -> U51^1(isNat(activate(V1)), activate(V2)) U51^1(tt, V2) -> ISNATLIST(activate(V2)) ISNATLIST(n__cons(V1, V2)) -> ISNAT(activate(V1)) ISNAT(n__s(V1)) -> ISNAT(activate(V1)) ISNAT(n__s(V1)) -> ACTIVATE(V1) ACTIVATE(n__length(X)) -> ACTIVATE(X) ACTIVATE(n__s(X)) -> ACTIVATE(X) ACTIVATE(n__cons(X1, X2)) -> ACTIVATE(X1) ISNATLIST(n__cons(V1, V2)) -> ACTIVATE(V1) ISNATLIST(n__cons(V1, V2)) -> ACTIVATE(V2) U51^1(tt, V2) -> ACTIVATE(V2) LENGTH(cons(N, L)) -> ACTIVATE(L) U62^1(tt, L) -> ACTIVATE(L) U61^1(tt, L, N) -> ISNAT(activate(N)) U61^1(tt, L, N) -> ACTIVATE(N) U61^1(tt, L, N) -> ACTIVATE(L) The TRS R consists of the following rules: zeros -> cons(0, n__zeros) U21(tt) -> tt U41(tt, V2) -> U42(isNatIList(activate(V2))) U42(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) isNatIList(n__cons(V1, V2)) -> U41(isNat(activate(V1)), activate(V2)) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) zeros -> n__zeros 0 -> n__0 length(X) -> n__length(X) s(X) -> n__s(X) cons(X1, X2) -> n__cons(X1, X2) nil -> n__nil activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (14) 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. No dependency pairs are removed. The following rules are removed from R: U41(tt, V2) -> U42(isNatIList(activate(V2))) U42(tt) -> tt isNatIList(n__cons(V1, V2)) -> U41(isNat(activate(V1)), activate(V2)) Used ordering: POLO with Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVATE(x_1)) = x_1 POL(ISNAT(x_1)) = x_1 POL(ISNATLIST(x_1)) = x_1 POL(LENGTH(x_1)) = 2*x_1 POL(U21(x_1)) = x_1 POL(U51(x_1, x_2)) = x_1 + x_2 POL(U51^1(x_1, x_2)) = x_1 + x_2 POL(U52(x_1)) = x_1 POL(U61(x_1, x_2, x_3)) = x_1 + 2*x_2 + 2*x_3 POL(U61^1(x_1, x_2, x_3)) = 2*x_1 + 2*x_2 + 2*x_3 POL(U62(x_1, x_2)) = x_1 + 2*x_2 POL(U62^1(x_1, x_2)) = x_1 + 2*x_2 POL(activate(x_1)) = x_1 POL(cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(isNat(x_1)) = 2*x_1 POL(isNatList(x_1)) = x_1 POL(length(x_1)) = 2*x_1 POL(n__0) = 0 POL(n__cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(n__length(x_1)) = 2*x_1 POL(n__nil) = 0 POL(n__s(x_1)) = x_1 POL(n__zeros) = 0 POL(nil) = 0 POL(s(x_1)) = x_1 POL(tt) = 0 POL(zeros) = 0 ---------------------------------------- (15) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVATE(n__length(X)) -> LENGTH(activate(X)) LENGTH(cons(N, L)) -> U61^1(isNatList(activate(L)), activate(L), N) U61^1(tt, L, N) -> U62^1(isNat(activate(N)), activate(L)) U62^1(tt, L) -> LENGTH(activate(L)) LENGTH(cons(N, L)) -> ISNATLIST(activate(L)) ISNATLIST(n__cons(V1, V2)) -> U51^1(isNat(activate(V1)), activate(V2)) U51^1(tt, V2) -> ISNATLIST(activate(V2)) ISNATLIST(n__cons(V1, V2)) -> ISNAT(activate(V1)) ISNAT(n__s(V1)) -> ISNAT(activate(V1)) ISNAT(n__s(V1)) -> ACTIVATE(V1) ACTIVATE(n__length(X)) -> ACTIVATE(X) ACTIVATE(n__s(X)) -> ACTIVATE(X) ACTIVATE(n__cons(X1, X2)) -> ACTIVATE(X1) ISNATLIST(n__cons(V1, V2)) -> ACTIVATE(V1) ISNATLIST(n__cons(V1, V2)) -> ACTIVATE(V2) U51^1(tt, V2) -> ACTIVATE(V2) LENGTH(cons(N, L)) -> ACTIVATE(L) U62^1(tt, L) -> ACTIVATE(L) U61^1(tt, L, N) -> ISNAT(activate(N)) U61^1(tt, L, N) -> ACTIVATE(N) U61^1(tt, L, N) -> ACTIVATE(L) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (16) 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: LENGTH(cons(N, L)) -> ISNATLIST(activate(L)) ACTIVATE(n__length(X)) -> ACTIVATE(X) LENGTH(cons(N, L)) -> ACTIVATE(L) U62^1(tt, L) -> ACTIVATE(L) U61^1(tt, L, N) -> ISNAT(activate(N)) U61^1(tt, L, N) -> ACTIVATE(N) U61^1(tt, L, N) -> ACTIVATE(L) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ACTIVATE(x_1)) = x_1 POL(ISNAT(x_1)) = 2*x_1 POL(ISNATLIST(x_1)) = 2*x_1 POL(LENGTH(x_1)) = 1 + x_1 POL(U21(x_1)) = x_1 POL(U51(x_1, x_2)) = 2*x_1 + x_2 POL(U51^1(x_1, x_2)) = 2*x_1 + 2*x_2 POL(U52(x_1)) = x_1 POL(U61(x_1, x_2, x_3)) = 1 + x_1 + 2*x_2 + 2*x_3 POL(U61^1(x_1, x_2, x_3)) = 1 + x_1 + x_2 + 2*x_3 POL(U62(x_1, x_2)) = 1 + 2*x_1 + 2*x_2 POL(U62^1(x_1, x_2)) = 1 + 2*x_1 + x_2 POL(activate(x_1)) = x_1 POL(cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(isNat(x_1)) = x_1 POL(isNatList(x_1)) = x_1 POL(length(x_1)) = 1 + 2*x_1 POL(n__0) = 0 POL(n__cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(n__length(x_1)) = 1 + 2*x_1 POL(n__nil) = 0 POL(n__s(x_1)) = x_1 POL(n__zeros) = 0 POL(nil) = 0 POL(s(x_1)) = x_1 POL(tt) = 0 POL(zeros) = 0 ---------------------------------------- (17) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVATE(n__length(X)) -> LENGTH(activate(X)) LENGTH(cons(N, L)) -> U61^1(isNatList(activate(L)), activate(L), N) U61^1(tt, L, N) -> U62^1(isNat(activate(N)), activate(L)) U62^1(tt, L) -> LENGTH(activate(L)) ISNATLIST(n__cons(V1, V2)) -> U51^1(isNat(activate(V1)), activate(V2)) U51^1(tt, V2) -> ISNATLIST(activate(V2)) ISNATLIST(n__cons(V1, V2)) -> ISNAT(activate(V1)) ISNAT(n__s(V1)) -> ISNAT(activate(V1)) ISNAT(n__s(V1)) -> ACTIVATE(V1) ACTIVATE(n__s(X)) -> ACTIVATE(X) ACTIVATE(n__cons(X1, X2)) -> ACTIVATE(X1) ISNATLIST(n__cons(V1, V2)) -> ACTIVATE(V1) ISNATLIST(n__cons(V1, V2)) -> ACTIVATE(V2) U51^1(tt, V2) -> ACTIVATE(V2) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (18) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 4 SCCs with 6 less nodes. ---------------------------------------- (19) Complex Obligation (AND) ---------------------------------------- (20) Obligation: Q DP problem: The TRS P consists of the following rules: U61^1(tt, L, N) -> U62^1(isNat(activate(N)), activate(L)) U62^1(tt, L) -> LENGTH(activate(L)) LENGTH(cons(N, L)) -> U61^1(isNatList(activate(L)), activate(L), N) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (21) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. U62^1(tt, L) -> LENGTH(activate(L)) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( LENGTH_1(x_1) ) = 2 POL( U61^1_3(x_1, ..., x_3) ) = 2x_1 + 2 POL( U62^1_2(x_1, x_2) ) = 2x_1 + 2 POL( U51_2(x_1, x_2) ) = max{0, -2} POL( U61_3(x_1, ..., x_3) ) = 2x_1 + 2 POL( U62_2(x_1, x_2) ) = 2x_1 + 2 POL( cons_2(x_1, x_2) ) = 2 POL( isNatList_1(x_1) ) = max{0, -2} POL( length_1(x_1) ) = 2 POL( s_1(x_1) ) = max{0, -2} POL( isNat_1(x_1) ) = 2 POL( U21_1(x_1) ) = x_1 POL( U52_1(x_1) ) = max{0, 2x_1 - 2} POL( activate_1(x_1) ) = 2 POL( n__zeros ) = 0 POL( zeros ) = 0 POL( n__0 ) = 0 POL( 0 ) = 0 POL( n__length_1(x_1) ) = 0 POL( n__s_1(x_1) ) = 0 POL( n__cons_2(x_1, x_2) ) = 0 POL( n__nil ) = 1 POL( nil ) = 2 POL( tt ) = 2 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) s(X) -> n__s(X) length(X) -> n__length(X) cons(X1, X2) -> n__cons(X1, X2) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) ---------------------------------------- (22) Obligation: Q DP problem: The TRS P consists of the following rules: U61^1(tt, L, N) -> U62^1(isNat(activate(N)), activate(L)) LENGTH(cons(N, L)) -> U61^1(isNatList(activate(L)), activate(L), N) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (23) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 2 less nodes. ---------------------------------------- (24) TRUE ---------------------------------------- (25) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVATE(n__cons(X1, X2)) -> ACTIVATE(X1) ACTIVATE(n__s(X)) -> ACTIVATE(X) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (26) UsableRulesProof (EQUIVALENT) We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (27) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVATE(n__cons(X1, X2)) -> ACTIVATE(X1) ACTIVATE(n__s(X)) -> ACTIVATE(X) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (28) 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: *ACTIVATE(n__cons(X1, X2)) -> ACTIVATE(X1) The graph contains the following edges 1 > 1 *ACTIVATE(n__s(X)) -> ACTIVATE(X) The graph contains the following edges 1 > 1 ---------------------------------------- (29) YES ---------------------------------------- (30) Obligation: Q DP problem: The TRS P consists of the following rules: ISNAT(n__s(V1)) -> ISNAT(activate(V1)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (31) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. ISNAT(n__s(V1)) -> ISNAT(activate(V1)) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( ISNAT_1(x_1) ) = 2x_1 POL( activate_1(x_1) ) = x_1 POL( n__zeros ) = 0 POL( zeros ) = 0 POL( n__0 ) = 2 POL( 0 ) = 2 POL( n__length_1(x_1) ) = 0 POL( length_1(x_1) ) = 0 POL( n__s_1(x_1) ) = 2x_1 + 1 POL( s_1(x_1) ) = 2x_1 + 1 POL( n__cons_2(x_1, x_2) ) = 0 POL( cons_2(x_1, x_2) ) = max{0, -2} POL( n__nil ) = 2 POL( nil ) = 2 POL( U61_3(x_1, ..., x_3) ) = max{0, 2x_1 - 2} POL( isNatList_1(x_1) ) = max{0, -2} POL( U51_2(x_1, x_2) ) = max{0, -2} POL( isNat_1(x_1) ) = 2x_1 + 2 POL( U21_1(x_1) ) = max{0, 2x_1 - 1} POL( U62_2(x_1, x_2) ) = 1 POL( tt ) = 2 POL( U52_1(x_1) ) = max{0, 2x_1 - 2} The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X s(X) -> n__s(X) length(X) -> n__length(X) cons(X1, X2) -> n__cons(X1, X2) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) zeros -> cons(0, n__zeros) zeros -> n__zeros 0 -> n__0 nil -> n__nil ---------------------------------------- (32) Obligation: Q DP problem: P is empty. The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (33) PisEmptyProof (EQUIVALENT) The TRS P is empty. Hence, there is no (P,Q,R) chain. ---------------------------------------- (34) YES ---------------------------------------- (35) Obligation: Q DP problem: The TRS P consists of the following rules: ISNATLIST(n__cons(V1, V2)) -> U51^1(isNat(activate(V1)), activate(V2)) U51^1(tt, V2) -> ISNATLIST(activate(V2)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (36) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule ISNATLIST(n__cons(V1, V2)) -> U51^1(isNat(activate(V1)), activate(V2)) at position [0] we obtained the following new rules [LPAR04]: (ISNATLIST(n__cons(n__zeros, y1)) -> U51^1(isNat(zeros), activate(y1)),ISNATLIST(n__cons(n__zeros, y1)) -> U51^1(isNat(zeros), activate(y1))) (ISNATLIST(n__cons(n__0, y1)) -> U51^1(isNat(0), activate(y1)),ISNATLIST(n__cons(n__0, y1)) -> U51^1(isNat(0), activate(y1))) (ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1)),ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1))) (ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)),ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1))) (ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)),ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1))) (ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1)),ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1))) (ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)),ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1))) ---------------------------------------- (37) Obligation: Q DP problem: The TRS P consists of the following rules: U51^1(tt, V2) -> ISNATLIST(activate(V2)) ISNATLIST(n__cons(n__zeros, y1)) -> U51^1(isNat(zeros), activate(y1)) ISNATLIST(n__cons(n__0, y1)) -> U51^1(isNat(0), activate(y1)) ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1)) ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)) ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)) ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1)) ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (38) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule U51^1(tt, V2) -> ISNATLIST(activate(V2)) at position [0] we obtained the following new rules [LPAR04]: (U51^1(tt, n__zeros) -> ISNATLIST(zeros),U51^1(tt, n__zeros) -> ISNATLIST(zeros)) (U51^1(tt, n__0) -> ISNATLIST(0),U51^1(tt, n__0) -> ISNATLIST(0)) (U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0))),U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0)))) (U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))),U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0)))) (U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)),U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1))) (U51^1(tt, n__nil) -> ISNATLIST(nil),U51^1(tt, n__nil) -> ISNATLIST(nil)) (U51^1(tt, x0) -> ISNATLIST(x0),U51^1(tt, x0) -> ISNATLIST(x0)) ---------------------------------------- (39) Obligation: Q DP problem: The TRS P consists of the following rules: ISNATLIST(n__cons(n__zeros, y1)) -> U51^1(isNat(zeros), activate(y1)) ISNATLIST(n__cons(n__0, y1)) -> U51^1(isNat(0), activate(y1)) ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1)) ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)) ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)) ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1)) ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) U51^1(tt, n__zeros) -> ISNATLIST(zeros) U51^1(tt, n__0) -> ISNATLIST(0) U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0))) U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))) U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)) U51^1(tt, n__nil) -> ISNATLIST(nil) U51^1(tt, x0) -> ISNATLIST(x0) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (40) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule ISNATLIST(n__cons(n__zeros, y1)) -> U51^1(isNat(zeros), activate(y1)) at position [0] we obtained the following new rules [LPAR04]: (ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0)),ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0))) (ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(n__zeros), activate(y0)),ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(n__zeros), activate(y0))) ---------------------------------------- (41) Obligation: Q DP problem: The TRS P consists of the following rules: ISNATLIST(n__cons(n__0, y1)) -> U51^1(isNat(0), activate(y1)) ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1)) ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)) ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)) ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1)) ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) U51^1(tt, n__zeros) -> ISNATLIST(zeros) U51^1(tt, n__0) -> ISNATLIST(0) U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0))) U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))) U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)) U51^1(tt, n__nil) -> ISNATLIST(nil) U51^1(tt, x0) -> ISNATLIST(x0) ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0)) ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(n__zeros), activate(y0)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (42) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (43) Obligation: Q DP problem: The TRS P consists of the following rules: U51^1(tt, n__zeros) -> ISNATLIST(zeros) ISNATLIST(n__cons(n__0, y1)) -> U51^1(isNat(0), activate(y1)) U51^1(tt, n__0) -> ISNATLIST(0) ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1)) U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0))) ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)) U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))) ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)) U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)) ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1)) U51^1(tt, n__nil) -> ISNATLIST(nil) ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) U51^1(tt, x0) -> ISNATLIST(x0) ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (44) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule U51^1(tt, n__zeros) -> ISNATLIST(zeros) at position [0] we obtained the following new rules [LPAR04]: (U51^1(tt, n__zeros) -> ISNATLIST(cons(0, n__zeros)),U51^1(tt, n__zeros) -> ISNATLIST(cons(0, n__zeros))) (U51^1(tt, n__zeros) -> ISNATLIST(n__zeros),U51^1(tt, n__zeros) -> ISNATLIST(n__zeros)) ---------------------------------------- (45) Obligation: Q DP problem: The TRS P consists of the following rules: ISNATLIST(n__cons(n__0, y1)) -> U51^1(isNat(0), activate(y1)) U51^1(tt, n__0) -> ISNATLIST(0) ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1)) U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0))) ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)) U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))) ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)) U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)) ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1)) U51^1(tt, n__nil) -> ISNATLIST(nil) ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) U51^1(tt, x0) -> ISNATLIST(x0) ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0)) U51^1(tt, n__zeros) -> ISNATLIST(cons(0, n__zeros)) U51^1(tt, n__zeros) -> ISNATLIST(n__zeros) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (46) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (47) Obligation: Q DP problem: The TRS P consists of the following rules: U51^1(tt, n__0) -> ISNATLIST(0) ISNATLIST(n__cons(n__0, y1)) -> U51^1(isNat(0), activate(y1)) U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0))) ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1)) U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))) ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)) U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)) ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)) U51^1(tt, n__nil) -> ISNATLIST(nil) ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1)) U51^1(tt, x0) -> ISNATLIST(x0) ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) U51^1(tt, n__zeros) -> ISNATLIST(cons(0, n__zeros)) ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (48) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule U51^1(tt, n__0) -> ISNATLIST(0) at position [0] we obtained the following new rules [LPAR04]: (U51^1(tt, n__0) -> ISNATLIST(n__0),U51^1(tt, n__0) -> ISNATLIST(n__0)) ---------------------------------------- (49) Obligation: Q DP problem: The TRS P consists of the following rules: ISNATLIST(n__cons(n__0, y1)) -> U51^1(isNat(0), activate(y1)) U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0))) ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1)) U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))) ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)) U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)) ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)) U51^1(tt, n__nil) -> ISNATLIST(nil) ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1)) U51^1(tt, x0) -> ISNATLIST(x0) ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) U51^1(tt, n__zeros) -> ISNATLIST(cons(0, n__zeros)) ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0)) U51^1(tt, n__0) -> ISNATLIST(n__0) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (50) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (51) Obligation: Q DP problem: The TRS P consists of the following rules: U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0))) ISNATLIST(n__cons(n__0, y1)) -> U51^1(isNat(0), activate(y1)) U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))) ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1)) U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)) ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)) U51^1(tt, n__nil) -> ISNATLIST(nil) ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)) U51^1(tt, x0) -> ISNATLIST(x0) ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1)) U51^1(tt, n__zeros) -> ISNATLIST(cons(0, n__zeros)) ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (52) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule ISNATLIST(n__cons(n__0, y1)) -> U51^1(isNat(0), activate(y1)) at position [0] we obtained the following new rules [LPAR04]: (ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0)),ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0))) ---------------------------------------- (53) Obligation: Q DP problem: The TRS P consists of the following rules: U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0))) U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))) ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1)) U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)) ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)) U51^1(tt, n__nil) -> ISNATLIST(nil) ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)) U51^1(tt, x0) -> ISNATLIST(x0) ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1)) U51^1(tt, n__zeros) -> ISNATLIST(cons(0, n__zeros)) ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0)) ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (54) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule U51^1(tt, n__nil) -> ISNATLIST(nil) at position [0] we obtained the following new rules [LPAR04]: (U51^1(tt, n__nil) -> ISNATLIST(n__nil),U51^1(tt, n__nil) -> ISNATLIST(n__nil)) ---------------------------------------- (55) Obligation: Q DP problem: The TRS P consists of the following rules: U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0))) U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))) ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1)) U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)) ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)) ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)) U51^1(tt, x0) -> ISNATLIST(x0) ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1)) U51^1(tt, n__zeros) -> ISNATLIST(cons(0, n__zeros)) ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0)) ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0)) U51^1(tt, n__nil) -> ISNATLIST(n__nil) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (56) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (57) Obligation: Q DP problem: The TRS P consists of the following rules: ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1)) U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0))) ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)) U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))) ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)) U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)) ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1)) U51^1(tt, x0) -> ISNATLIST(x0) ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) U51^1(tt, n__zeros) -> ISNATLIST(cons(0, n__zeros)) ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0)) ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (58) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule ISNATLIST(n__cons(n__nil, y1)) -> U51^1(isNat(nil), activate(y1)) at position [0] we obtained the following new rules [LPAR04]: (ISNATLIST(n__cons(n__nil, y0)) -> U51^1(isNat(n__nil), activate(y0)),ISNATLIST(n__cons(n__nil, y0)) -> U51^1(isNat(n__nil), activate(y0))) ---------------------------------------- (59) Obligation: Q DP problem: The TRS P consists of the following rules: ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1)) U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0))) ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)) U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))) ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)) U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)) U51^1(tt, x0) -> ISNATLIST(x0) ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) U51^1(tt, n__zeros) -> ISNATLIST(cons(0, n__zeros)) ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0)) ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0)) ISNATLIST(n__cons(n__nil, y0)) -> U51^1(isNat(n__nil), activate(y0)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (60) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (61) Obligation: Q DP problem: The TRS P consists of the following rules: U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0))) ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1)) U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))) ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)) U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)) ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)) U51^1(tt, x0) -> ISNATLIST(x0) ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) U51^1(tt, n__zeros) -> ISNATLIST(cons(0, n__zeros)) ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0)) ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (62) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule U51^1(tt, n__zeros) -> ISNATLIST(cons(0, n__zeros)) at position [0] we obtained the following new rules [LPAR04]: (U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros)),U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros))) (U51^1(tt, n__zeros) -> ISNATLIST(cons(n__0, n__zeros)),U51^1(tt, n__zeros) -> ISNATLIST(cons(n__0, n__zeros))) ---------------------------------------- (63) Obligation: Q DP problem: The TRS P consists of the following rules: U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0))) ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1)) U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))) ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)) U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)) ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)) U51^1(tt, x0) -> ISNATLIST(x0) ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0)) ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0)) U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros)) U51^1(tt, n__zeros) -> ISNATLIST(cons(n__0, n__zeros)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (64) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(0, n__zeros)), activate(y0)) at position [0] we obtained the following new rules [LPAR04]: (ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(n__cons(0, n__zeros)), activate(y0)),ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(n__cons(0, n__zeros)), activate(y0))) (ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(n__0, n__zeros)), activate(y0)),ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(n__0, n__zeros)), activate(y0))) ---------------------------------------- (65) Obligation: Q DP problem: The TRS P consists of the following rules: U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0))) ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1)) U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))) ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)) U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)) ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)) U51^1(tt, x0) -> ISNATLIST(x0) ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0)) U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros)) U51^1(tt, n__zeros) -> ISNATLIST(cons(n__0, n__zeros)) ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(n__cons(0, n__zeros)), activate(y0)) ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(n__0, n__zeros)), activate(y0)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (66) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (67) Obligation: Q DP problem: The TRS P consists of the following rules: ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1)) U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0))) ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)) U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))) ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)) U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)) ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) U51^1(tt, x0) -> ISNATLIST(x0) ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0)) U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros)) ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(n__0, n__zeros)), activate(y0)) U51^1(tt, n__zeros) -> ISNATLIST(cons(n__0, n__zeros)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (68) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(cons(n__0, n__zeros)), activate(y0)) at position [0] we obtained the following new rules [LPAR04]: (ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(n__cons(n__0, n__zeros)), activate(y0)),ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(n__cons(n__0, n__zeros)), activate(y0))) ---------------------------------------- (69) Obligation: Q DP problem: The TRS P consists of the following rules: ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1)) U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0))) ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)) U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))) ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)) U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)) ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) U51^1(tt, x0) -> ISNATLIST(x0) ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0)) U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros)) U51^1(tt, n__zeros) -> ISNATLIST(cons(n__0, n__zeros)) ISNATLIST(n__cons(n__zeros, y0)) -> U51^1(isNat(n__cons(n__0, n__zeros)), activate(y0)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (70) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (71) Obligation: Q DP problem: The TRS P consists of the following rules: U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0))) ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1)) U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))) ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)) U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)) ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)) U51^1(tt, x0) -> ISNATLIST(x0) ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros)) ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0)) U51^1(tt, n__zeros) -> ISNATLIST(cons(n__0, n__zeros)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (72) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule U51^1(tt, n__zeros) -> ISNATLIST(cons(n__0, n__zeros)) at position [0] we obtained the following new rules [LPAR04]: (U51^1(tt, n__zeros) -> ISNATLIST(n__cons(n__0, n__zeros)),U51^1(tt, n__zeros) -> ISNATLIST(n__cons(n__0, n__zeros))) ---------------------------------------- (73) Obligation: Q DP problem: The TRS P consists of the following rules: U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0))) ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1)) U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))) ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)) U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)) ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)) U51^1(tt, x0) -> ISNATLIST(x0) ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros)) ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0)) U51^1(tt, n__zeros) -> ISNATLIST(n__cons(n__0, n__zeros)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (74) 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: ISNATLIST(n__cons(n__length(x0), y1)) -> U51^1(isNat(length(activate(x0))), activate(y1)) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ISNATLIST(x_1)) = 2*x_1 POL(U21(x_1)) = x_1 POL(U51(x_1, x_2)) = 2*x_1 + 2*x_2 POL(U51^1(x_1, x_2)) = 2*x_1 + 2*x_2 POL(U52(x_1)) = 2*x_1 POL(U61(x_1, x_2, x_3)) = 1 + x_1 + x_2 + 2*x_3 POL(U62(x_1, x_2)) = 1 + x_1 + x_2 POL(activate(x_1)) = x_1 POL(cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(isNat(x_1)) = x_1 POL(isNatList(x_1)) = x_1 POL(length(x_1)) = 1 + x_1 POL(n__0) = 0 POL(n__cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(n__length(x_1)) = 1 + x_1 POL(n__nil) = 0 POL(n__s(x_1)) = x_1 POL(n__zeros) = 0 POL(nil) = 0 POL(s(x_1)) = x_1 POL(tt) = 0 POL(zeros) = 0 ---------------------------------------- (75) Obligation: Q DP problem: The TRS P consists of the following rules: U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0))) U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))) ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)) U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)) ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)) U51^1(tt, x0) -> ISNATLIST(x0) ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros)) ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0)) U51^1(tt, n__zeros) -> ISNATLIST(n__cons(n__0, n__zeros)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (76) 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: U51^1(tt, n__length(x0)) -> ISNATLIST(length(activate(x0))) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ISNATLIST(x_1)) = x_1 POL(U21(x_1)) = x_1 POL(U51(x_1, x_2)) = 2*x_1 + 2*x_2 POL(U51^1(x_1, x_2)) = 2*x_1 + 2*x_2 POL(U52(x_1)) = 2*x_1 POL(U61(x_1, x_2, x_3)) = 2 + x_1 + x_2 + 2*x_3 POL(U62(x_1, x_2)) = 2 + 2*x_1 + x_2 POL(activate(x_1)) = x_1 POL(cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(isNat(x_1)) = x_1 POL(isNatList(x_1)) = x_1 POL(length(x_1)) = 2 + x_1 POL(n__0) = 0 POL(n__cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(n__length(x_1)) = 2 + x_1 POL(n__nil) = 0 POL(n__s(x_1)) = x_1 POL(n__zeros) = 0 POL(nil) = 0 POL(s(x_1)) = x_1 POL(tt) = 0 POL(zeros) = 0 ---------------------------------------- (77) Obligation: Q DP problem: The TRS P consists of the following rules: U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))) ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)) U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)) ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)) U51^1(tt, x0) -> ISNATLIST(x0) ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros)) ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0)) U51^1(tt, n__zeros) -> ISNATLIST(n__cons(n__0, n__zeros)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (78) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. ISNATLIST(n__cons(n__s(x0), y1)) -> U51^1(isNat(s(activate(x0))), activate(y1)) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( U51^1_2(x_1, x_2) ) = 2x_2 POL( ISNATLIST_1(x_1) ) = 2x_1 POL( cons_2(x_1, x_2) ) = 2x_1 + x_2 POL( s_1(x_1) ) = 1 POL( U51_2(x_1, x_2) ) = max{0, -2} POL( U61_3(x_1, ..., x_3) ) = 1 POL( U62_2(x_1, x_2) ) = 1 POL( length_1(x_1) ) = 2 POL( U21_1(x_1) ) = max{0, -2} POL( isNat_1(x_1) ) = max{0, -2} POL( U52_1(x_1) ) = max{0, -2} POL( isNatList_1(x_1) ) = 0 POL( activate_1(x_1) ) = x_1 POL( n__zeros ) = 0 POL( zeros ) = 0 POL( n__0 ) = 0 POL( 0 ) = 0 POL( n__length_1(x_1) ) = 2 POL( n__s_1(x_1) ) = 1 POL( n__cons_2(x_1, x_2) ) = 2x_1 + x_2 POL( n__nil ) = 2 POL( nil ) = 2 POL( tt ) = 0 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X s(X) -> n__s(X) isNat(n__s(V1)) -> U21(isNat(activate(V1))) cons(X1, X2) -> n__cons(X1, X2) 0 -> n__0 length(X) -> n__length(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) zeros -> cons(0, n__zeros) zeros -> n__zeros nil -> n__nil ---------------------------------------- (79) Obligation: Q DP problem: The TRS P consists of the following rules: U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))) U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)) ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)) U51^1(tt, x0) -> ISNATLIST(x0) ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros)) ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0)) U51^1(tt, n__zeros) -> ISNATLIST(n__cons(n__0, n__zeros)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (80) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. U51^1(tt, n__s(x0)) -> ISNATLIST(s(activate(x0))) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( U51^1_2(x_1, x_2) ) = 2x_2 POL( ISNATLIST_1(x_1) ) = x_1 POL( cons_2(x_1, x_2) ) = 2x_2 POL( s_1(x_1) ) = 1 POL( U51_2(x_1, x_2) ) = 2 POL( U61_3(x_1, ..., x_3) ) = 2 POL( U62_2(x_1, x_2) ) = 2 POL( length_1(x_1) ) = 2 POL( U21_1(x_1) ) = max{0, -2} POL( isNat_1(x_1) ) = max{0, -2} POL( U52_1(x_1) ) = max{0, -2} POL( isNatList_1(x_1) ) = 2 POL( activate_1(x_1) ) = x_1 POL( n__zeros ) = 0 POL( zeros ) = 0 POL( n__0 ) = 0 POL( 0 ) = 0 POL( n__length_1(x_1) ) = 2 POL( n__s_1(x_1) ) = 1 POL( n__cons_2(x_1, x_2) ) = 2x_2 POL( n__nil ) = 2 POL( nil ) = 2 POL( tt ) = 0 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X s(X) -> n__s(X) cons(X1, X2) -> n__cons(X1, X2) isNat(n__s(V1)) -> U21(isNat(activate(V1))) 0 -> n__0 length(X) -> n__length(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) zeros -> cons(0, n__zeros) zeros -> n__zeros nil -> n__nil ---------------------------------------- (81) Obligation: Q DP problem: The TRS P consists of the following rules: U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)) ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)) U51^1(tt, x0) -> ISNATLIST(x0) ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros)) ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0)) U51^1(tt, n__zeros) -> ISNATLIST(n__cons(n__0, n__zeros)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (82) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. ISNATLIST(n__cons(n__cons(x0, x1), y1)) -> U51^1(isNat(cons(activate(x0), x1)), activate(y1)) The remaining pairs can at least be oriented weakly. Used ordering: Matrix interpretation [MATRO] to (N^2, +, *, >=, >) : <<< POL(U51^1(x_1, x_2)) = [[0]] + [[0, 0]] * x_1 + [[1, 0]] * x_2 >>> <<< POL(tt) = [[0], [0]] >>> <<< POL(n__cons(x_1, x_2)) = [[0], [1]] + [[0, 1], [0, 1]] * x_1 + [[1, 0], [0, 0]] * x_2 >>> <<< POL(ISNATLIST(x_1)) = [[0]] + [[1, 0]] * x_1 >>> <<< POL(cons(x_1, x_2)) = [[0], [1]] + [[0, 1], [0, 1]] * x_1 + [[1, 0], [0, 0]] * x_2 >>> <<< POL(activate(x_1)) = [[0], [0]] + [[1, 0], [0, 1]] * x_1 >>> <<< POL(isNat(x_1)) = [[1], [0]] + [[0, 0], [0, 0]] * x_1 >>> <<< POL(n__zeros) = [[0], [1]] >>> <<< POL(0) = [[0], [0]] >>> <<< POL(n__0) = [[0], [0]] >>> <<< POL(zeros) = [[0], [1]] >>> <<< POL(n__length(x_1)) = [[0], [0]] + [[0, 0], [0, 0]] * x_1 >>> <<< POL(length(x_1)) = [[0], [0]] + [[0, 0], [0, 0]] * x_1 >>> <<< POL(n__s(x_1)) = [[0], [0]] + [[0, 0], [0, 0]] * x_1 >>> <<< POL(s(x_1)) = [[0], [0]] + [[0, 0], [0, 0]] * x_1 >>> <<< POL(n__nil) = [[1], [1]] >>> <<< POL(nil) = [[1], [1]] >>> <<< POL(U21(x_1)) = [[0], [0]] + [[0, 0], [0, 0]] * x_1 >>> <<< POL(U61(x_1, x_2, x_3)) = [[0], [0]] + [[0, 0], [0, 0]] * x_1 + [[0, 0], [0, 0]] * x_2 + [[0, 0], [0, 0]] * x_3 >>> <<< POL(isNatList(x_1)) = [[0], [0]] + [[0, 0], [0, 1]] * x_1 >>> <<< POL(U51(x_1, x_2)) = [[0], [0]] + [[0, 0], [0, 0]] * x_1 + [[0, 0], [0, 0]] * x_2 >>> <<< POL(U52(x_1)) = [[0], [0]] + [[0, 0], [0, 0]] * x_1 >>> <<< POL(U62(x_1, x_2)) = [[0], [0]] + [[0, 0], [0, 0]] * x_1 + [[0, 0], [0, 0]] * x_2 >>> The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X cons(X1, X2) -> n__cons(X1, X2) isNat(n__s(V1)) -> U21(isNat(activate(V1))) 0 -> n__0 s(X) -> n__s(X) length(X) -> n__length(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) zeros -> cons(0, n__zeros) zeros -> n__zeros nil -> n__nil ---------------------------------------- (83) Obligation: Q DP problem: The TRS P consists of the following rules: U51^1(tt, n__cons(x0, x1)) -> ISNATLIST(cons(activate(x0), x1)) U51^1(tt, x0) -> ISNATLIST(x0) ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) U51^1(tt, n__zeros) -> ISNATLIST(n__cons(0, n__zeros)) ISNATLIST(n__cons(n__0, y0)) -> U51^1(isNat(n__0), activate(y0)) U51^1(tt, n__zeros) -> ISNATLIST(n__cons(n__0, n__zeros)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U62(tt, L) -> s(length(activate(L))) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (84) NonTerminationLoopProof (COMPLETE) We used the non-termination processor [FROCOS05] to show that the DP problem is infinite. Found a loop by narrowing to the left: s = U51^1(isNat(n__0), activate(n__zeros)) evaluates to t =U51^1(isNat(n__0), activate(n__zeros)) Thus s starts an infinite chain as s semiunifies with t with the following substitutions: * Matcher: [ ] * Semiunifier: [ ] -------------------------------------------------------------------------------- Rewriting sequence U51^1(isNat(n__0), activate(n__zeros)) -> U51^1(isNat(n__0), n__zeros) with rule activate(X) -> X at position [1] and matcher [X / n__zeros] U51^1(isNat(n__0), n__zeros) -> U51^1(tt, n__zeros) with rule isNat(n__0) -> tt at position [0] and matcher [ ] U51^1(tt, n__zeros) -> ISNATLIST(n__cons(n__0, n__zeros)) with rule U51^1(tt, n__zeros) -> ISNATLIST(n__cons(n__0, n__zeros)) at position [] and matcher [ ] ISNATLIST(n__cons(n__0, n__zeros)) -> U51^1(isNat(n__0), activate(n__zeros)) with rule ISNATLIST(n__cons(x0, y1)) -> U51^1(isNat(x0), activate(y1)) Now applying the matcher to the start term leads to a term which is equal to the last term in the rewriting sequence All these steps are and every following step will be a correct step w.r.t to Q. ---------------------------------------- (85) NO ---------------------------------------- (86) Obligation: Q DP problem: The TRS P consists of the following rules: U41^1(tt, V2) -> ISNATILIST(activate(V2)) ISNATILIST(n__cons(V1, V2)) -> U41^1(isNat(activate(V1)), activate(V2)) The TRS R consists of the following rules: zeros -> cons(0, n__zeros) U21(tt) -> tt U41(tt, V2) -> U42(isNatIList(activate(V2))) U42(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) isNatIList(n__cons(V1, V2)) -> U41(isNat(activate(V1)), activate(V2)) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) zeros -> n__zeros 0 -> n__0 length(X) -> n__length(X) s(X) -> n__s(X) cons(X1, X2) -> n__cons(X1, X2) nil -> n__nil activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (87) 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. No dependency pairs are removed. The following rules are removed from R: U41(tt, V2) -> U42(isNatIList(activate(V2))) U42(tt) -> tt isNatIList(n__cons(V1, V2)) -> U41(isNat(activate(V1)), activate(V2)) Used ordering: POLO with Polynomial interpretation [POLO]: POL(0) = 0 POL(ISNATILIST(x_1)) = 2*x_1 POL(U21(x_1)) = x_1 POL(U41^1(x_1, x_2)) = 2*x_1 + 2*x_2 POL(U51(x_1, x_2)) = x_1 + x_2 POL(U52(x_1)) = x_1 POL(U61(x_1, x_2, x_3)) = x_1 + x_2 + 2*x_3 POL(U62(x_1, x_2)) = x_1 + x_2 POL(activate(x_1)) = x_1 POL(cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(isNat(x_1)) = 2*x_1 POL(isNatList(x_1)) = x_1 POL(length(x_1)) = x_1 POL(n__0) = 0 POL(n__cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(n__length(x_1)) = x_1 POL(n__nil) = 2 POL(n__s(x_1)) = x_1 POL(n__zeros) = 0 POL(nil) = 2 POL(s(x_1)) = x_1 POL(tt) = 0 POL(zeros) = 0 ---------------------------------------- (88) Obligation: Q DP problem: The TRS P consists of the following rules: U41^1(tt, V2) -> ISNATILIST(activate(V2)) ISNATILIST(n__cons(V1, V2)) -> U41^1(isNat(activate(V1)), activate(V2)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (89) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule U41^1(tt, V2) -> ISNATILIST(activate(V2)) at position [0] we obtained the following new rules [LPAR04]: (U41^1(tt, n__zeros) -> ISNATILIST(zeros),U41^1(tt, n__zeros) -> ISNATILIST(zeros)) (U41^1(tt, n__0) -> ISNATILIST(0),U41^1(tt, n__0) -> ISNATILIST(0)) (U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0))),U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0)))) (U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))),U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0)))) (U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)),U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1))) (U41^1(tt, n__nil) -> ISNATILIST(nil),U41^1(tt, n__nil) -> ISNATILIST(nil)) (U41^1(tt, x0) -> ISNATILIST(x0),U41^1(tt, x0) -> ISNATILIST(x0)) ---------------------------------------- (90) Obligation: Q DP problem: The TRS P consists of the following rules: ISNATILIST(n__cons(V1, V2)) -> U41^1(isNat(activate(V1)), activate(V2)) U41^1(tt, n__zeros) -> ISNATILIST(zeros) U41^1(tt, n__0) -> ISNATILIST(0) U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0))) U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))) U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)) U41^1(tt, n__nil) -> ISNATILIST(nil) U41^1(tt, x0) -> ISNATILIST(x0) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (91) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule ISNATILIST(n__cons(V1, V2)) -> U41^1(isNat(activate(V1)), activate(V2)) at position [0] we obtained the following new rules [LPAR04]: (ISNATILIST(n__cons(n__zeros, y1)) -> U41^1(isNat(zeros), activate(y1)),ISNATILIST(n__cons(n__zeros, y1)) -> U41^1(isNat(zeros), activate(y1))) (ISNATILIST(n__cons(n__0, y1)) -> U41^1(isNat(0), activate(y1)),ISNATILIST(n__cons(n__0, y1)) -> U41^1(isNat(0), activate(y1))) (ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1)),ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1))) (ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1)),ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1))) (ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)),ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1))) (ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1)),ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1))) (ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)),ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1))) ---------------------------------------- (92) Obligation: Q DP problem: The TRS P consists of the following rules: U41^1(tt, n__zeros) -> ISNATILIST(zeros) U41^1(tt, n__0) -> ISNATILIST(0) U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0))) U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))) U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)) U41^1(tt, n__nil) -> ISNATILIST(nil) U41^1(tt, x0) -> ISNATILIST(x0) ISNATILIST(n__cons(n__zeros, y1)) -> U41^1(isNat(zeros), activate(y1)) ISNATILIST(n__cons(n__0, y1)) -> U41^1(isNat(0), activate(y1)) ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1)) ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1)) ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)) ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1)) ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (93) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule U41^1(tt, n__zeros) -> ISNATILIST(zeros) at position [0] we obtained the following new rules [LPAR04]: (U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros)),U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros))) (U41^1(tt, n__zeros) -> ISNATILIST(n__zeros),U41^1(tt, n__zeros) -> ISNATILIST(n__zeros)) ---------------------------------------- (94) Obligation: Q DP problem: The TRS P consists of the following rules: U41^1(tt, n__0) -> ISNATILIST(0) U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0))) U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))) U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)) U41^1(tt, n__nil) -> ISNATILIST(nil) U41^1(tt, x0) -> ISNATILIST(x0) ISNATILIST(n__cons(n__zeros, y1)) -> U41^1(isNat(zeros), activate(y1)) ISNATILIST(n__cons(n__0, y1)) -> U41^1(isNat(0), activate(y1)) ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1)) ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1)) ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)) ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1)) ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)) U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros)) U41^1(tt, n__zeros) -> ISNATILIST(n__zeros) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (95) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (96) Obligation: Q DP problem: The TRS P consists of the following rules: ISNATILIST(n__cons(n__zeros, y1)) -> U41^1(isNat(zeros), activate(y1)) U41^1(tt, n__0) -> ISNATILIST(0) ISNATILIST(n__cons(n__0, y1)) -> U41^1(isNat(0), activate(y1)) U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0))) ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1)) U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))) ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1)) U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)) ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)) U41^1(tt, n__nil) -> ISNATILIST(nil) ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1)) U41^1(tt, x0) -> ISNATILIST(x0) ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)) U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (97) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule ISNATILIST(n__cons(n__zeros, y1)) -> U41^1(isNat(zeros), activate(y1)) at position [0] we obtained the following new rules [LPAR04]: (ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(0, n__zeros)), activate(y0)),ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(0, n__zeros)), activate(y0))) (ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(n__zeros), activate(y0)),ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(n__zeros), activate(y0))) ---------------------------------------- (98) Obligation: Q DP problem: The TRS P consists of the following rules: U41^1(tt, n__0) -> ISNATILIST(0) ISNATILIST(n__cons(n__0, y1)) -> U41^1(isNat(0), activate(y1)) U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0))) ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1)) U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))) ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1)) U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)) ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)) U41^1(tt, n__nil) -> ISNATILIST(nil) ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1)) U41^1(tt, x0) -> ISNATILIST(x0) ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)) U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros)) ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(0, n__zeros)), activate(y0)) ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(n__zeros), activate(y0)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. 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 1 less node. ---------------------------------------- (100) Obligation: Q DP problem: The TRS P consists of the following rules: ISNATILIST(n__cons(n__0, y1)) -> U41^1(isNat(0), activate(y1)) U41^1(tt, n__0) -> ISNATILIST(0) ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1)) U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0))) ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1)) U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))) ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)) U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)) ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1)) U41^1(tt, n__nil) -> ISNATILIST(nil) ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)) U41^1(tt, x0) -> ISNATILIST(x0) ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(0, n__zeros)), activate(y0)) U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (101) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule ISNATILIST(n__cons(n__0, y1)) -> U41^1(isNat(0), activate(y1)) at position [0] we obtained the following new rules [LPAR04]: (ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0)),ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0))) ---------------------------------------- (102) Obligation: Q DP problem: The TRS P consists of the following rules: U41^1(tt, n__0) -> ISNATILIST(0) ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1)) U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0))) ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1)) U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))) ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)) U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)) ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1)) U41^1(tt, n__nil) -> ISNATILIST(nil) ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)) U41^1(tt, x0) -> ISNATILIST(x0) ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(0, n__zeros)), activate(y0)) U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros)) ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (103) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule U41^1(tt, n__0) -> ISNATILIST(0) at position [0] we obtained the following new rules [LPAR04]: (U41^1(tt, n__0) -> ISNATILIST(n__0),U41^1(tt, n__0) -> ISNATILIST(n__0)) ---------------------------------------- (104) Obligation: Q DP problem: The TRS P consists of the following rules: ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1)) U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0))) ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1)) U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))) ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)) U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)) ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1)) U41^1(tt, n__nil) -> ISNATILIST(nil) ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)) U41^1(tt, x0) -> ISNATILIST(x0) ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(0, n__zeros)), activate(y0)) U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros)) ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0)) U41^1(tt, n__0) -> ISNATILIST(n__0) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (105) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (106) Obligation: Q DP problem: The TRS P consists of the following rules: U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0))) ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1)) U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))) ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1)) U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)) ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)) U41^1(tt, n__nil) -> ISNATILIST(nil) ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1)) U41^1(tt, x0) -> ISNATILIST(x0) ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)) U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros)) ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(0, n__zeros)), activate(y0)) ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (107) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule U41^1(tt, n__nil) -> ISNATILIST(nil) at position [0] we obtained the following new rules [LPAR04]: (U41^1(tt, n__nil) -> ISNATILIST(n__nil),U41^1(tt, n__nil) -> ISNATILIST(n__nil)) ---------------------------------------- (108) Obligation: Q DP problem: The TRS P consists of the following rules: U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0))) ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1)) U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))) ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1)) U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)) ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)) ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1)) U41^1(tt, x0) -> ISNATILIST(x0) ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)) U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros)) ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(0, n__zeros)), activate(y0)) ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0)) U41^1(tt, n__nil) -> ISNATILIST(n__nil) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. 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: ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1)) U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0))) ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1)) U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))) ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)) U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)) ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1)) U41^1(tt, x0) -> ISNATILIST(x0) ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)) U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros)) ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(0, n__zeros)), activate(y0)) ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (111) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule ISNATILIST(n__cons(n__nil, y1)) -> U41^1(isNat(nil), activate(y1)) at position [0] we obtained the following new rules [LPAR04]: (ISNATILIST(n__cons(n__nil, y0)) -> U41^1(isNat(n__nil), activate(y0)),ISNATILIST(n__cons(n__nil, y0)) -> U41^1(isNat(n__nil), activate(y0))) ---------------------------------------- (112) Obligation: Q DP problem: The TRS P consists of the following rules: ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1)) U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0))) ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1)) U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))) ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)) U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)) U41^1(tt, x0) -> ISNATILIST(x0) ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)) U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros)) ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(0, n__zeros)), activate(y0)) ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0)) ISNATILIST(n__cons(n__nil, y0)) -> U41^1(isNat(n__nil), activate(y0)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. 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: U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0))) ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1)) U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))) ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1)) U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)) ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)) U41^1(tt, x0) -> ISNATILIST(x0) ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)) U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros)) ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(0, n__zeros)), activate(y0)) ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (115) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule U41^1(tt, n__zeros) -> ISNATILIST(cons(0, n__zeros)) at position [0] we obtained the following new rules [LPAR04]: (U41^1(tt, n__zeros) -> ISNATILIST(n__cons(0, n__zeros)),U41^1(tt, n__zeros) -> ISNATILIST(n__cons(0, n__zeros))) (U41^1(tt, n__zeros) -> ISNATILIST(cons(n__0, n__zeros)),U41^1(tt, n__zeros) -> ISNATILIST(cons(n__0, n__zeros))) ---------------------------------------- (116) Obligation: Q DP problem: The TRS P consists of the following rules: U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0))) ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1)) U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))) ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1)) U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)) ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)) U41^1(tt, x0) -> ISNATILIST(x0) ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)) ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(0, n__zeros)), activate(y0)) ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0)) U41^1(tt, n__zeros) -> ISNATILIST(n__cons(0, n__zeros)) U41^1(tt, n__zeros) -> ISNATILIST(cons(n__0, n__zeros)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (117) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(0, n__zeros)), activate(y0)) at position [0] we obtained the following new rules [LPAR04]: (ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(n__cons(0, n__zeros)), activate(y0)),ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(n__cons(0, n__zeros)), activate(y0))) (ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(n__0, n__zeros)), activate(y0)),ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(n__0, n__zeros)), activate(y0))) ---------------------------------------- (118) Obligation: Q DP problem: The TRS P consists of the following rules: U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0))) ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1)) U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))) ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1)) U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)) ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)) U41^1(tt, x0) -> ISNATILIST(x0) ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)) ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0)) U41^1(tt, n__zeros) -> ISNATILIST(n__cons(0, n__zeros)) U41^1(tt, n__zeros) -> ISNATILIST(cons(n__0, n__zeros)) ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(n__cons(0, n__zeros)), activate(y0)) ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(n__0, n__zeros)), activate(y0)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (119) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (120) Obligation: Q DP problem: The TRS P consists of the following rules: ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1)) U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0))) ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1)) U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))) ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)) U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)) ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)) U41^1(tt, x0) -> ISNATILIST(x0) ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0)) U41^1(tt, n__zeros) -> ISNATILIST(n__cons(0, n__zeros)) ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(n__0, n__zeros)), activate(y0)) U41^1(tt, n__zeros) -> ISNATILIST(cons(n__0, n__zeros)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (121) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(cons(n__0, n__zeros)), activate(y0)) at position [0] we obtained the following new rules [LPAR04]: (ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(n__cons(n__0, n__zeros)), activate(y0)),ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(n__cons(n__0, n__zeros)), activate(y0))) ---------------------------------------- (122) Obligation: Q DP problem: The TRS P consists of the following rules: ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1)) U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0))) ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1)) U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))) ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)) U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)) ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)) U41^1(tt, x0) -> ISNATILIST(x0) ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0)) U41^1(tt, n__zeros) -> ISNATILIST(n__cons(0, n__zeros)) U41^1(tt, n__zeros) -> ISNATILIST(cons(n__0, n__zeros)) ISNATILIST(n__cons(n__zeros, y0)) -> U41^1(isNat(n__cons(n__0, n__zeros)), activate(y0)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (123) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (124) Obligation: Q DP problem: The TRS P consists of the following rules: U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0))) ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1)) U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))) ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1)) U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)) ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)) U41^1(tt, x0) -> ISNATILIST(x0) ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)) U41^1(tt, n__zeros) -> ISNATILIST(n__cons(0, n__zeros)) ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0)) U41^1(tt, n__zeros) -> ISNATILIST(cons(n__0, n__zeros)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (125) TransformationProof (EQUIVALENT) By narrowing [LPAR04] the rule U41^1(tt, n__zeros) -> ISNATILIST(cons(n__0, n__zeros)) at position [0] we obtained the following new rules [LPAR04]: (U41^1(tt, n__zeros) -> ISNATILIST(n__cons(n__0, n__zeros)),U41^1(tt, n__zeros) -> ISNATILIST(n__cons(n__0, n__zeros))) ---------------------------------------- (126) Obligation: Q DP problem: The TRS P consists of the following rules: U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0))) ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1)) U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))) ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1)) U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)) ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)) U41^1(tt, x0) -> ISNATILIST(x0) ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)) U41^1(tt, n__zeros) -> ISNATILIST(n__cons(0, n__zeros)) ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0)) U41^1(tt, n__zeros) -> ISNATILIST(n__cons(n__0, n__zeros)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (127) 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: U41^1(tt, n__length(x0)) -> ISNATILIST(length(activate(x0))) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ISNATILIST(x_1)) = x_1 POL(U21(x_1)) = x_1 POL(U41^1(x_1, x_2)) = 2*x_1 + 2*x_2 POL(U51(x_1, x_2)) = 2*x_1 + x_2 POL(U52(x_1)) = x_1 POL(U61(x_1, x_2, x_3)) = 1 + x_1 + 2*x_2 + 2*x_3 POL(U62(x_1, x_2)) = 1 + 2*x_1 + 2*x_2 POL(activate(x_1)) = x_1 POL(cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(isNat(x_1)) = x_1 POL(isNatList(x_1)) = x_1 POL(length(x_1)) = 1 + 2*x_1 POL(n__0) = 0 POL(n__cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(n__length(x_1)) = 1 + 2*x_1 POL(n__nil) = 0 POL(n__s(x_1)) = x_1 POL(n__zeros) = 0 POL(nil) = 0 POL(s(x_1)) = x_1 POL(tt) = 0 POL(zeros) = 0 ---------------------------------------- (128) Obligation: Q DP problem: The TRS P consists of the following rules: ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1)) U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))) ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1)) U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)) ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)) U41^1(tt, x0) -> ISNATILIST(x0) ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)) U41^1(tt, n__zeros) -> ISNATILIST(n__cons(0, n__zeros)) ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0)) U41^1(tt, n__zeros) -> ISNATILIST(n__cons(n__0, n__zeros)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (129) 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: ISNATILIST(n__cons(n__length(x0), y1)) -> U41^1(isNat(length(activate(x0))), activate(y1)) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(ISNATILIST(x_1)) = 2 + 2*x_1 POL(U21(x_1)) = x_1 POL(U41^1(x_1, x_2)) = 2*x_1 + 2*x_2 POL(U51(x_1, x_2)) = x_1 + x_2 POL(U52(x_1)) = x_1 POL(U61(x_1, x_2, x_3)) = 1 + x_1 + 2*x_2 + 2*x_3 POL(U62(x_1, x_2)) = 1 + x_1 + 2*x_2 POL(activate(x_1)) = x_1 POL(cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(isNat(x_1)) = 1 + x_1 POL(isNatList(x_1)) = 1 + x_1 POL(length(x_1)) = 2 + 2*x_1 POL(n__0) = 0 POL(n__cons(x_1, x_2)) = 2*x_1 + 2*x_2 POL(n__length(x_1)) = 2 + 2*x_1 POL(n__nil) = 0 POL(n__s(x_1)) = x_1 POL(n__zeros) = 0 POL(nil) = 0 POL(s(x_1)) = x_1 POL(tt) = 1 POL(zeros) = 0 ---------------------------------------- (130) Obligation: Q DP problem: The TRS P consists of the following rules: U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))) ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1)) U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)) ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)) U41^1(tt, x0) -> ISNATILIST(x0) ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)) U41^1(tt, n__zeros) -> ISNATILIST(n__cons(0, n__zeros)) ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0)) U41^1(tt, n__zeros) -> ISNATILIST(n__cons(n__0, n__zeros)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (131) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. ISNATILIST(n__cons(n__s(x0), y1)) -> U41^1(isNat(s(activate(x0))), activate(y1)) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( U41^1_2(x_1, x_2) ) = max{0, 2x_1 + 2x_2 - 2} POL( ISNATILIST_1(x_1) ) = 2x_1 POL( cons_2(x_1, x_2) ) = 2x_1 + 2x_2 POL( s_1(x_1) ) = 1 POL( U51_2(x_1, x_2) ) = max{0, -2} POL( U61_3(x_1, ..., x_3) ) = 2x_1 POL( U62_2(x_1, x_2) ) = 2 POL( length_1(x_1) ) = max{0, -2} POL( U21_1(x_1) ) = max{0, 2x_1 - 1} POL( isNat_1(x_1) ) = 1 POL( U52_1(x_1) ) = max{0, 2x_1 - 1} POL( isNatList_1(x_1) ) = max{0, -2} POL( activate_1(x_1) ) = x_1 POL( n__zeros ) = 0 POL( zeros ) = 0 POL( n__0 ) = 0 POL( 0 ) = 0 POL( n__length_1(x_1) ) = 0 POL( n__s_1(x_1) ) = 1 POL( n__cons_2(x_1, x_2) ) = 2x_1 + 2x_2 POL( n__nil ) = 2 POL( nil ) = 2 POL( tt ) = 1 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X s(X) -> n__s(X) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) cons(X1, X2) -> n__cons(X1, X2) 0 -> n__0 length(X) -> n__length(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) zeros -> cons(0, n__zeros) zeros -> n__zeros nil -> n__nil ---------------------------------------- (132) Obligation: Q DP problem: The TRS P consists of the following rules: U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))) U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)) ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)) U41^1(tt, x0) -> ISNATILIST(x0) ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)) U41^1(tt, n__zeros) -> ISNATILIST(n__cons(0, n__zeros)) ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0)) U41^1(tt, n__zeros) -> ISNATILIST(n__cons(n__0, n__zeros)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (133) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. U41^1(tt, n__s(x0)) -> ISNATILIST(s(activate(x0))) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( U41^1_2(x_1, x_2) ) = 2x_2 + 2 POL( ISNATILIST_1(x_1) ) = x_1 + 2 POL( cons_2(x_1, x_2) ) = 2x_2 POL( s_1(x_1) ) = 2 POL( U51_2(x_1, x_2) ) = max{0, -2} POL( U61_3(x_1, ..., x_3) ) = 2x_1 + 2 POL( U62_2(x_1, x_2) ) = 2x_1 + 2 POL( length_1(x_1) ) = 2 POL( U21_1(x_1) ) = max{0, 2x_1 - 2} POL( isNat_1(x_1) ) = 2 POL( U52_1(x_1) ) = max{0, 2x_1 - 2} POL( isNatList_1(x_1) ) = max{0, -2} POL( activate_1(x_1) ) = x_1 POL( n__zeros ) = 0 POL( zeros ) = 0 POL( n__0 ) = 0 POL( 0 ) = 0 POL( n__length_1(x_1) ) = 2 POL( n__s_1(x_1) ) = 2 POL( n__cons_2(x_1, x_2) ) = 2x_2 POL( n__nil ) = 2 POL( nil ) = 2 POL( tt ) = 2 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X s(X) -> n__s(X) cons(X1, X2) -> n__cons(X1, X2) isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) 0 -> n__0 length(X) -> n__length(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) zeros -> cons(0, n__zeros) zeros -> n__zeros nil -> n__nil ---------------------------------------- (134) Obligation: Q DP problem: The TRS P consists of the following rules: U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)) ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)) U41^1(tt, x0) -> ISNATILIST(x0) ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)) U41^1(tt, n__zeros) -> ISNATILIST(n__cons(0, n__zeros)) ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0)) U41^1(tt, n__zeros) -> ISNATILIST(n__cons(n__0, n__zeros)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (135) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. ISNATILIST(n__cons(n__cons(x0, x1), y1)) -> U41^1(isNat(cons(activate(x0), x1)), activate(y1)) The remaining pairs can at least be oriented weakly. Used ordering: Matrix interpretation [MATRO] to (N^2, +, *, >=, >) : <<< POL(U41^1(x_1, x_2)) = [[0]] + [[0, 0]] * x_1 + [[1, 0]] * x_2 >>> <<< POL(tt) = [[0], [0]] >>> <<< POL(n__cons(x_1, x_2)) = [[0], [1]] + [[0, 1], [0, 1]] * x_1 + [[1, 0], [0, 0]] * x_2 >>> <<< POL(ISNATILIST(x_1)) = [[0]] + [[1, 0]] * x_1 >>> <<< POL(cons(x_1, x_2)) = [[0], [1]] + [[0, 1], [0, 1]] * x_1 + [[1, 0], [0, 0]] * x_2 >>> <<< POL(activate(x_1)) = [[0], [0]] + [[1, 0], [0, 1]] * x_1 >>> <<< POL(isNat(x_1)) = [[1], [0]] + [[0, 0], [0, 0]] * x_1 >>> <<< POL(n__zeros) = [[0], [1]] >>> <<< POL(0) = [[0], [0]] >>> <<< POL(n__0) = [[0], [0]] >>> <<< POL(zeros) = [[0], [1]] >>> <<< POL(n__length(x_1)) = [[0], [0]] + [[0, 0], [0, 0]] * x_1 >>> <<< POL(length(x_1)) = [[0], [0]] + [[0, 0], [0, 0]] * x_1 >>> <<< POL(n__s(x_1)) = [[0], [0]] + [[0, 0], [0, 0]] * x_1 >>> <<< POL(s(x_1)) = [[0], [0]] + [[0, 0], [0, 0]] * x_1 >>> <<< POL(n__nil) = [[1], [1]] >>> <<< POL(nil) = [[1], [1]] >>> <<< POL(U21(x_1)) = [[0], [0]] + [[0, 0], [0, 0]] * x_1 >>> <<< POL(U61(x_1, x_2, x_3)) = [[0], [0]] + [[0, 0], [0, 0]] * x_1 + [[0, 0], [0, 0]] * x_2 + [[0, 0], [0, 0]] * x_3 >>> <<< POL(isNatList(x_1)) = [[0], [0]] + [[0, 0], [0, 1]] * x_1 >>> <<< POL(U51(x_1, x_2)) = [[0], [0]] + [[0, 0], [0, 0]] * x_1 + [[0, 0], [0, 0]] * x_2 >>> <<< POL(U52(x_1)) = [[0], [0]] + [[0, 0], [0, 0]] * x_1 >>> <<< POL(U62(x_1, x_2)) = [[0], [0]] + [[0, 0], [0, 0]] * x_1 + [[0, 0], [0, 0]] * x_2 >>> The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X cons(X1, X2) -> n__cons(X1, X2) isNat(n__s(V1)) -> U21(isNat(activate(V1))) 0 -> n__0 s(X) -> n__s(X) length(X) -> n__length(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U21(tt) -> tt U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) zeros -> cons(0, n__zeros) zeros -> n__zeros nil -> n__nil ---------------------------------------- (136) Obligation: Q DP problem: The TRS P consists of the following rules: U41^1(tt, n__cons(x0, x1)) -> ISNATILIST(cons(activate(x0), x1)) U41^1(tt, x0) -> ISNATILIST(x0) ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)) U41^1(tt, n__zeros) -> ISNATILIST(n__cons(0, n__zeros)) ISNATILIST(n__cons(n__0, y0)) -> U41^1(isNat(n__0), activate(y0)) U41^1(tt, n__zeros) -> ISNATILIST(n__cons(n__0, n__zeros)) The TRS R consists of the following rules: activate(n__zeros) -> zeros activate(n__0) -> 0 activate(n__length(X)) -> length(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__cons(X1, X2)) -> cons(activate(X1), X2) activate(n__nil) -> nil activate(X) -> X isNat(n__0) -> tt isNat(n__s(V1)) -> U21(isNat(activate(V1))) U21(tt) -> tt nil -> n__nil cons(X1, X2) -> n__cons(X1, X2) s(X) -> n__s(X) length(cons(N, L)) -> U61(isNatList(activate(L)), activate(L), N) length(X) -> n__length(X) isNatList(n__cons(V1, V2)) -> U51(isNat(activate(V1)), activate(V2)) U61(tt, L, N) -> U62(isNat(activate(N)), activate(L)) U62(tt, L) -> s(length(activate(L))) U51(tt, V2) -> U52(isNatList(activate(V2))) U52(tt) -> tt 0 -> n__0 zeros -> cons(0, n__zeros) zeros -> n__zeros Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (137) NonTerminationLoopProof (COMPLETE) We used the non-termination processor [FROCOS05] to show that the DP problem is infinite. Found a loop by narrowing to the left: s = U41^1(isNat(n__0), activate(n__zeros)) evaluates to t =U41^1(isNat(n__0), activate(n__zeros)) Thus s starts an infinite chain as s semiunifies with t with the following substitutions: * Matcher: [ ] * Semiunifier: [ ] -------------------------------------------------------------------------------- Rewriting sequence U41^1(isNat(n__0), activate(n__zeros)) -> U41^1(isNat(n__0), n__zeros) with rule activate(X) -> X at position [1] and matcher [X / n__zeros] U41^1(isNat(n__0), n__zeros) -> U41^1(tt, n__zeros) with rule isNat(n__0) -> tt at position [0] and matcher [ ] U41^1(tt, n__zeros) -> ISNATILIST(n__cons(n__0, n__zeros)) with rule U41^1(tt, n__zeros) -> ISNATILIST(n__cons(n__0, n__zeros)) at position [] and matcher [ ] ISNATILIST(n__cons(n__0, n__zeros)) -> U41^1(isNat(n__0), activate(n__zeros)) with rule ISNATILIST(n__cons(x0, y1)) -> U41^1(isNat(x0), activate(y1)) Now applying the matcher to the start term leads to a term which is equal to the last term in the rewriting sequence All these steps are and every following step will be a correct step w.r.t to Q. ---------------------------------------- (138) NO