/export/starexec/sandbox/solver/bin/starexec_run_standard /export/starexec/sandbox/benchmark/theBenchmark.pl /export/starexec/sandbox/output/output_files -------------------------------------------------------------------------------- MAYBE proof of /export/starexec/sandbox/benchmark/theBenchmark.pl # AProVE Commit ID: 48fb2092695e11cc9f56e44b17a92a5f88ffb256 marcel 20180622 unpublished dirty Left Termination of the query pattern div(g,g,a) w.r.t. the given Prolog program could not be shown: (0) Prolog (1) PrologToPiTRSProof [SOUND, 0 ms] (2) PiTRS (3) DependencyPairsProof [EQUIVALENT, 24 ms] (4) PiDP (5) DependencyGraphProof [EQUIVALENT, 0 ms] (6) AND (7) PiDP (8) UsableRulesProof [EQUIVALENT, 0 ms] (9) PiDP (10) PiDPToQDPProof [SOUND, 0 ms] (11) QDP (12) QDPSizeChangeProof [EQUIVALENT, 0 ms] (13) YES (14) PiDP (15) UsableRulesProof [EQUIVALENT, 0 ms] (16) PiDP (17) PiDPToQDPProof [SOUND, 0 ms] (18) QDP (19) QDPSizeChangeProof [EQUIVALENT, 0 ms] (20) YES (21) PiDP (22) UsableRulesProof [EQUIVALENT, 0 ms] (23) PiDP (24) PiDPToQDPProof [SOUND, 0 ms] (25) QDP (26) QDPQMonotonicMRRProof [EQUIVALENT, 27 ms] (27) QDP (28) UsableRulesProof [EQUIVALENT, 0 ms] (29) QDP (30) QReductionProof [EQUIVALENT, 0 ms] (31) QDP (32) TransformationProof [SOUND, 1 ms] (33) QDP (34) UsableRulesProof [EQUIVALENT, 0 ms] (35) QDP (36) QReductionProof [EQUIVALENT, 0 ms] (37) QDP (38) TransformationProof [EQUIVALENT, 0 ms] (39) QDP (40) TransformationProof [EQUIVALENT, 0 ms] (41) QDP (42) TransformationProof [EQUIVALENT, 0 ms] (43) QDP (44) QDPQMonotonicMRRProof [EQUIVALENT, 16 ms] (45) QDP (46) TransformationProof [SOUND, 0 ms] (47) QDP (48) UsableRulesProof [EQUIVALENT, 0 ms] (49) QDP (50) TransformationProof [EQUIVALENT, 0 ms] (51) QDP (52) UsableRulesProof [EQUIVALENT, 0 ms] (53) QDP (54) QReductionProof [EQUIVALENT, 0 ms] (55) QDP (56) TransformationProof [EQUIVALENT, 0 ms] (57) QDP (58) UsableRulesProof [EQUIVALENT, 0 ms] (59) QDP (60) QReductionProof [EQUIVALENT, 0 ms] (61) QDP (62) TransformationProof [EQUIVALENT, 0 ms] (63) QDP (64) TransformationProof [EQUIVALENT, 0 ms] (65) QDP (66) TransformationProof [EQUIVALENT, 0 ms] (67) QDP (68) NonTerminationLoopProof [COMPLETE, 0 ms] (69) NO (70) PrologToPiTRSProof [SOUND, 0 ms] (71) PiTRS (72) DependencyPairsProof [EQUIVALENT, 0 ms] (73) PiDP (74) DependencyGraphProof [EQUIVALENT, 0 ms] (75) AND (76) PiDP (77) UsableRulesProof [EQUIVALENT, 0 ms] (78) PiDP (79) PiDPToQDPProof [SOUND, 11 ms] (80) QDP (81) QDPSizeChangeProof [EQUIVALENT, 0 ms] (82) YES (83) PiDP (84) UsableRulesProof [EQUIVALENT, 0 ms] (85) PiDP (86) PiDPToQDPProof [SOUND, 0 ms] (87) QDP (88) QDPSizeChangeProof [EQUIVALENT, 0 ms] (89) YES (90) PiDP (91) UsableRulesProof [EQUIVALENT, 0 ms] (92) PiDP (93) PiDPToQDPProof [SOUND, 2 ms] (94) QDP (95) TransformationProof [SOUND, 0 ms] (96) QDP (97) TransformationProof [SOUND, 0 ms] (98) QDP (99) TransformationProof [EQUIVALENT, 0 ms] (100) QDP (101) DependencyGraphProof [EQUIVALENT, 0 ms] (102) QDP (103) TransformationProof [EQUIVALENT, 0 ms] (104) QDP (105) TransformationProof [EQUIVALENT, 0 ms] (106) QDP (107) TransformationProof [EQUIVALENT, 0 ms] (108) QDP (109) TransformationProof [EQUIVALENT, 0 ms] (110) QDP (111) TransformationProof [EQUIVALENT, 0 ms] (112) QDP (113) TransformationProof [EQUIVALENT, 0 ms] (114) QDP (115) DependencyGraphProof [EQUIVALENT, 0 ms] (116) AND (117) QDP (118) UsableRulesProof [EQUIVALENT, 0 ms] (119) QDP (120) QReductionProof [EQUIVALENT, 0 ms] (121) QDP (122) NonTerminationLoopProof [COMPLETE, 0 ms] (123) NO (124) QDP (125) TransformationProof [EQUIVALENT, 0 ms] (126) QDP (127) TransformationProof [EQUIVALENT, 0 ms] (128) QDP (129) QDPOrderProof [EQUIVALENT, 17 ms] (130) QDP (131) DependencyGraphProof [EQUIVALENT, 0 ms] (132) TRUE (133) PrologToTRSTransformerProof [SOUND, 28 ms] (134) QTRS (135) Overlay + Local Confluence [EQUIVALENT, 0 ms] (136) QTRS (137) DependencyPairsProof [EQUIVALENT, 0 ms] (138) QDP (139) DependencyGraphProof [EQUIVALENT, 0 ms] (140) AND (141) QDP (142) UsableRulesProof [EQUIVALENT, 0 ms] (143) QDP (144) QReductionProof [EQUIVALENT, 0 ms] (145) QDP (146) QDPSizeChangeProof [EQUIVALENT, 0 ms] (147) YES (148) QDP (149) UsableRulesProof [EQUIVALENT, 0 ms] (150) QDP (151) QReductionProof [EQUIVALENT, 0 ms] (152) QDP (153) QDPSizeChangeProof [EQUIVALENT, 0 ms] (154) YES (155) QDP (156) UsableRulesProof [EQUIVALENT, 0 ms] (157) QDP (158) QReductionProof [EQUIVALENT, 0 ms] (159) QDP (160) MNOCProof [EQUIVALENT, 0 ms] (161) QDP (162) NonTerminationLoopProof [COMPLETE, 11 ms] (163) NO (164) PrologToIRSwTTransformerProof [SOUND, 40 ms] (165) AND (166) IRSwT (167) IRSwTSimpleDependencyGraphProof [EQUIVALENT, 0 ms] (168) TRUE (169) IRSwT (170) IRSwTSimpleDependencyGraphProof [EQUIVALENT, 0 ms] (171) IRSwT (172) IntTRSCompressionProof [EQUIVALENT, 21 ms] (173) IRSwT (174) IRSFormatTransformerProof [EQUIVALENT, 0 ms] (175) IRSwT (176) IRSwTTerminationDigraphProof [EQUIVALENT, 6 ms] (177) IRSwT (178) TempFilterProof [SOUND, 3 ms] (179) IRSwT (180) IRSwTToQDPProof [SOUND, 0 ms] (181) QDP (182) QDPSizeChangeProof [EQUIVALENT, 0 ms] (183) YES (184) IRSwT (185) IRSwTSimpleDependencyGraphProof [EQUIVALENT, 3 ms] (186) IRSwT (187) IntTRSCompressionProof [EQUIVALENT, 31 ms] (188) IRSwT (189) IRSFormatTransformerProof [EQUIVALENT, 0 ms] (190) IRSwT (191) IRSwTTerminationDigraphProof [EQUIVALENT, 81 ms] (192) IRSwT (193) IntTRSCompressionProof [EQUIVALENT, 12 ms] (194) IRSwT (195) IntTRSUnneededArgumentFilterProof [EQUIVALENT, 1 ms] (196) IRSwT (197) IRSwTToIntTRSProof [SOUND, 21 ms] (198) IRSwT (199) IntTRSCompressionProof [EQUIVALENT, 9 ms] (200) IRSwT (201) PrologToDTProblemTransformerProof [SOUND, 44 ms] (202) TRIPLES (203) TriplesToPiDPProof [SOUND, 12 ms] (204) PiDP (205) DependencyGraphProof [EQUIVALENT, 0 ms] (206) AND (207) PiDP (208) UsableRulesProof [EQUIVALENT, 0 ms] (209) PiDP (210) PiDPToQDPProof [SOUND, 0 ms] (211) QDP (212) QDPSizeChangeProof [EQUIVALENT, 0 ms] (213) YES (214) PiDP (215) UsableRulesProof [EQUIVALENT, 0 ms] (216) PiDP (217) PiDPToQDPProof [SOUND, 0 ms] (218) QDP (219) QDPSizeChangeProof [EQUIVALENT, 0 ms] (220) YES (221) PiDP (222) PiDPToQDPProof [SOUND, 0 ms] (223) QDP (224) QDPQMonotonicMRRProof [EQUIVALENT, 43 ms] (225) QDP (226) QDPQMonotonicMRRProof [EQUIVALENT, 41 ms] (227) QDP (228) UsableRulesProof [EQUIVALENT, 0 ms] (229) QDP (230) QReductionProof [EQUIVALENT, 0 ms] (231) QDP (232) TransformationProof [SOUND, 0 ms] (233) QDP (234) UsableRulesProof [EQUIVALENT, 0 ms] (235) QDP (236) QReductionProof [EQUIVALENT, 0 ms] (237) QDP (238) TransformationProof [EQUIVALENT, 0 ms] (239) QDP (240) TransformationProof [EQUIVALENT, 0 ms] (241) QDP (242) UsableRulesProof [EQUIVALENT, 0 ms] (243) QDP (244) QReductionProof [EQUIVALENT, 0 ms] (245) QDP (246) TransformationProof [EQUIVALENT, 1 ms] (247) QDP (248) UsableRulesProof [EQUIVALENT, 0 ms] (249) QDP (250) QReductionProof [EQUIVALENT, 0 ms] (251) QDP (252) NonTerminationLoopProof [COMPLETE, 0 ms] (253) NO ---------------------------------------- (0) Obligation: Clauses: le(0, Y, true). le(s(X), 0, false). le(s(X), s(Y), B) :- le(X, Y, B). minus(X, 0, X). minus(s(X), s(Y), Z) :- minus(X, Y, Z). div(X, s(Y), Z) :- ','(le(s(Y), X, B), if(B, X, s(Y), Z)). if(false, X, s(Y), 0). if(true, X, s(Y), s(Z)) :- ','(minus(X, Y, U), div(U, s(Y), Z)). Query: div(g,g,a) ---------------------------------------- (1) PrologToPiTRSProof (SOUND) We use the technique of [TOCL09]. With regard to the inferred argument filtering the predicates were used in the following modes: div_in_3: (b,b,f) le_in_3: (b,b,f) if_in_4: (b,b,b,f) minus_in_3: (b,b,f) Transforming Prolog into the following Term Rewriting System: Pi-finite rewrite system: The TRS R consists of the following rules: div_in_gga(X, s(Y), Z) -> U3_gga(X, Y, Z, le_in_gga(s(Y), X, B)) le_in_gga(0, Y, true) -> le_out_gga(0, Y, true) le_in_gga(s(X), 0, false) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y), B) -> U1_gga(X, Y, B, le_in_gga(X, Y, B)) U1_gga(X, Y, B, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) U3_gga(X, Y, Z, le_out_gga(s(Y), X, B)) -> U4_gga(X, Y, Z, if_in_ggga(B, X, s(Y), Z)) if_in_ggga(false, X, s(Y), 0) -> if_out_ggga(false, X, s(Y), 0) if_in_ggga(true, X, s(Y), s(Z)) -> U5_ggga(X, Y, Z, minus_in_gga(X, Y, U)) minus_in_gga(X, 0, X) -> minus_out_gga(X, 0, X) minus_in_gga(s(X), s(Y), Z) -> U2_gga(X, Y, Z, minus_in_gga(X, Y, Z)) U2_gga(X, Y, Z, minus_out_gga(X, Y, Z)) -> minus_out_gga(s(X), s(Y), Z) U5_ggga(X, Y, Z, minus_out_gga(X, Y, U)) -> U6_ggga(X, Y, Z, div_in_gga(U, s(Y), Z)) U6_ggga(X, Y, Z, div_out_gga(U, s(Y), Z)) -> if_out_ggga(true, X, s(Y), s(Z)) U4_gga(X, Y, Z, if_out_ggga(B, X, s(Y), Z)) -> div_out_gga(X, s(Y), Z) The argument filtering Pi contains the following mapping: div_in_gga(x1, x2, x3) = div_in_gga(x1, x2) s(x1) = s(x1) U3_gga(x1, x2, x3, x4) = U3_gga(x1, x2, x4) le_in_gga(x1, x2, x3) = le_in_gga(x1, x2) 0 = 0 le_out_gga(x1, x2, x3) = le_out_gga(x1, x2, x3) U1_gga(x1, x2, x3, x4) = U1_gga(x1, x2, x4) U4_gga(x1, x2, x3, x4) = U4_gga(x1, x2, x4) if_in_ggga(x1, x2, x3, x4) = if_in_ggga(x1, x2, x3) false = false if_out_ggga(x1, x2, x3, x4) = if_out_ggga(x1, x2, x3, x4) true = true U5_ggga(x1, x2, x3, x4) = U5_ggga(x1, x2, x4) minus_in_gga(x1, x2, x3) = minus_in_gga(x1, x2) minus_out_gga(x1, x2, x3) = minus_out_gga(x1, x2, x3) U2_gga(x1, x2, x3, x4) = U2_gga(x1, x2, x4) U6_ggga(x1, x2, x3, x4) = U6_ggga(x1, x2, x4) div_out_gga(x1, x2, x3) = div_out_gga(x1, x2, x3) Infinitary Constructor Rewriting Termination of PiTRS implies Termination of Prolog ---------------------------------------- (2) Obligation: Pi-finite rewrite system: The TRS R consists of the following rules: div_in_gga(X, s(Y), Z) -> U3_gga(X, Y, Z, le_in_gga(s(Y), X, B)) le_in_gga(0, Y, true) -> le_out_gga(0, Y, true) le_in_gga(s(X), 0, false) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y), B) -> U1_gga(X, Y, B, le_in_gga(X, Y, B)) U1_gga(X, Y, B, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) U3_gga(X, Y, Z, le_out_gga(s(Y), X, B)) -> U4_gga(X, Y, Z, if_in_ggga(B, X, s(Y), Z)) if_in_ggga(false, X, s(Y), 0) -> if_out_ggga(false, X, s(Y), 0) if_in_ggga(true, X, s(Y), s(Z)) -> U5_ggga(X, Y, Z, minus_in_gga(X, Y, U)) minus_in_gga(X, 0, X) -> minus_out_gga(X, 0, X) minus_in_gga(s(X), s(Y), Z) -> U2_gga(X, Y, Z, minus_in_gga(X, Y, Z)) U2_gga(X, Y, Z, minus_out_gga(X, Y, Z)) -> minus_out_gga(s(X), s(Y), Z) U5_ggga(X, Y, Z, minus_out_gga(X, Y, U)) -> U6_ggga(X, Y, Z, div_in_gga(U, s(Y), Z)) U6_ggga(X, Y, Z, div_out_gga(U, s(Y), Z)) -> if_out_ggga(true, X, s(Y), s(Z)) U4_gga(X, Y, Z, if_out_ggga(B, X, s(Y), Z)) -> div_out_gga(X, s(Y), Z) The argument filtering Pi contains the following mapping: div_in_gga(x1, x2, x3) = div_in_gga(x1, x2) s(x1) = s(x1) U3_gga(x1, x2, x3, x4) = U3_gga(x1, x2, x4) le_in_gga(x1, x2, x3) = le_in_gga(x1, x2) 0 = 0 le_out_gga(x1, x2, x3) = le_out_gga(x1, x2, x3) U1_gga(x1, x2, x3, x4) = U1_gga(x1, x2, x4) U4_gga(x1, x2, x3, x4) = U4_gga(x1, x2, x4) if_in_ggga(x1, x2, x3, x4) = if_in_ggga(x1, x2, x3) false = false if_out_ggga(x1, x2, x3, x4) = if_out_ggga(x1, x2, x3, x4) true = true U5_ggga(x1, x2, x3, x4) = U5_ggga(x1, x2, x4) minus_in_gga(x1, x2, x3) = minus_in_gga(x1, x2) minus_out_gga(x1, x2, x3) = minus_out_gga(x1, x2, x3) U2_gga(x1, x2, x3, x4) = U2_gga(x1, x2, x4) U6_ggga(x1, x2, x3, x4) = U6_ggga(x1, x2, x4) div_out_gga(x1, x2, x3) = div_out_gga(x1, x2, x3) ---------------------------------------- (3) DependencyPairsProof (EQUIVALENT) Using Dependency Pairs [AG00,LOPSTR] we result in the following initial DP problem: Pi DP problem: The TRS P consists of the following rules: DIV_IN_GGA(X, s(Y), Z) -> U3_GGA(X, Y, Z, le_in_gga(s(Y), X, B)) DIV_IN_GGA(X, s(Y), Z) -> LE_IN_GGA(s(Y), X, B) LE_IN_GGA(s(X), s(Y), B) -> U1_GGA(X, Y, B, le_in_gga(X, Y, B)) LE_IN_GGA(s(X), s(Y), B) -> LE_IN_GGA(X, Y, B) U3_GGA(X, Y, Z, le_out_gga(s(Y), X, B)) -> U4_GGA(X, Y, Z, if_in_ggga(B, X, s(Y), Z)) U3_GGA(X, Y, Z, le_out_gga(s(Y), X, B)) -> IF_IN_GGGA(B, X, s(Y), Z) IF_IN_GGGA(true, X, s(Y), s(Z)) -> U5_GGGA(X, Y, Z, minus_in_gga(X, Y, U)) IF_IN_GGGA(true, X, s(Y), s(Z)) -> MINUS_IN_GGA(X, Y, U) MINUS_IN_GGA(s(X), s(Y), Z) -> U2_GGA(X, Y, Z, minus_in_gga(X, Y, Z)) MINUS_IN_GGA(s(X), s(Y), Z) -> MINUS_IN_GGA(X, Y, Z) U5_GGGA(X, Y, Z, minus_out_gga(X, Y, U)) -> U6_GGGA(X, Y, Z, div_in_gga(U, s(Y), Z)) U5_GGGA(X, Y, Z, minus_out_gga(X, Y, U)) -> DIV_IN_GGA(U, s(Y), Z) The TRS R consists of the following rules: div_in_gga(X, s(Y), Z) -> U3_gga(X, Y, Z, le_in_gga(s(Y), X, B)) le_in_gga(0, Y, true) -> le_out_gga(0, Y, true) le_in_gga(s(X), 0, false) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y), B) -> U1_gga(X, Y, B, le_in_gga(X, Y, B)) U1_gga(X, Y, B, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) U3_gga(X, Y, Z, le_out_gga(s(Y), X, B)) -> U4_gga(X, Y, Z, if_in_ggga(B, X, s(Y), Z)) if_in_ggga(false, X, s(Y), 0) -> if_out_ggga(false, X, s(Y), 0) if_in_ggga(true, X, s(Y), s(Z)) -> U5_ggga(X, Y, Z, minus_in_gga(X, Y, U)) minus_in_gga(X, 0, X) -> minus_out_gga(X, 0, X) minus_in_gga(s(X), s(Y), Z) -> U2_gga(X, Y, Z, minus_in_gga(X, Y, Z)) U2_gga(X, Y, Z, minus_out_gga(X, Y, Z)) -> minus_out_gga(s(X), s(Y), Z) U5_ggga(X, Y, Z, minus_out_gga(X, Y, U)) -> U6_ggga(X, Y, Z, div_in_gga(U, s(Y), Z)) U6_ggga(X, Y, Z, div_out_gga(U, s(Y), Z)) -> if_out_ggga(true, X, s(Y), s(Z)) U4_gga(X, Y, Z, if_out_ggga(B, X, s(Y), Z)) -> div_out_gga(X, s(Y), Z) The argument filtering Pi contains the following mapping: div_in_gga(x1, x2, x3) = div_in_gga(x1, x2) s(x1) = s(x1) U3_gga(x1, x2, x3, x4) = U3_gga(x1, x2, x4) le_in_gga(x1, x2, x3) = le_in_gga(x1, x2) 0 = 0 le_out_gga(x1, x2, x3) = le_out_gga(x1, x2, x3) U1_gga(x1, x2, x3, x4) = U1_gga(x1, x2, x4) U4_gga(x1, x2, x3, x4) = U4_gga(x1, x2, x4) if_in_ggga(x1, x2, x3, x4) = if_in_ggga(x1, x2, x3) false = false if_out_ggga(x1, x2, x3, x4) = if_out_ggga(x1, x2, x3, x4) true = true U5_ggga(x1, x2, x3, x4) = U5_ggga(x1, x2, x4) minus_in_gga(x1, x2, x3) = minus_in_gga(x1, x2) minus_out_gga(x1, x2, x3) = minus_out_gga(x1, x2, x3) U2_gga(x1, x2, x3, x4) = U2_gga(x1, x2, x4) U6_ggga(x1, x2, x3, x4) = U6_ggga(x1, x2, x4) div_out_gga(x1, x2, x3) = div_out_gga(x1, x2, x3) DIV_IN_GGA(x1, x2, x3) = DIV_IN_GGA(x1, x2) U3_GGA(x1, x2, x3, x4) = U3_GGA(x1, x2, x4) LE_IN_GGA(x1, x2, x3) = LE_IN_GGA(x1, x2) U1_GGA(x1, x2, x3, x4) = U1_GGA(x1, x2, x4) U4_GGA(x1, x2, x3, x4) = U4_GGA(x1, x2, x4) IF_IN_GGGA(x1, x2, x3, x4) = IF_IN_GGGA(x1, x2, x3) U5_GGGA(x1, x2, x3, x4) = U5_GGGA(x1, x2, x4) MINUS_IN_GGA(x1, x2, x3) = MINUS_IN_GGA(x1, x2) U2_GGA(x1, x2, x3, x4) = U2_GGA(x1, x2, x4) U6_GGGA(x1, x2, x3, x4) = U6_GGGA(x1, x2, x4) We have to consider all (P,R,Pi)-chains ---------------------------------------- (4) Obligation: Pi DP problem: The TRS P consists of the following rules: DIV_IN_GGA(X, s(Y), Z) -> U3_GGA(X, Y, Z, le_in_gga(s(Y), X, B)) DIV_IN_GGA(X, s(Y), Z) -> LE_IN_GGA(s(Y), X, B) LE_IN_GGA(s(X), s(Y), B) -> U1_GGA(X, Y, B, le_in_gga(X, Y, B)) LE_IN_GGA(s(X), s(Y), B) -> LE_IN_GGA(X, Y, B) U3_GGA(X, Y, Z, le_out_gga(s(Y), X, B)) -> U4_GGA(X, Y, Z, if_in_ggga(B, X, s(Y), Z)) U3_GGA(X, Y, Z, le_out_gga(s(Y), X, B)) -> IF_IN_GGGA(B, X, s(Y), Z) IF_IN_GGGA(true, X, s(Y), s(Z)) -> U5_GGGA(X, Y, Z, minus_in_gga(X, Y, U)) IF_IN_GGGA(true, X, s(Y), s(Z)) -> MINUS_IN_GGA(X, Y, U) MINUS_IN_GGA(s(X), s(Y), Z) -> U2_GGA(X, Y, Z, minus_in_gga(X, Y, Z)) MINUS_IN_GGA(s(X), s(Y), Z) -> MINUS_IN_GGA(X, Y, Z) U5_GGGA(X, Y, Z, minus_out_gga(X, Y, U)) -> U6_GGGA(X, Y, Z, div_in_gga(U, s(Y), Z)) U5_GGGA(X, Y, Z, minus_out_gga(X, Y, U)) -> DIV_IN_GGA(U, s(Y), Z) The TRS R consists of the following rules: div_in_gga(X, s(Y), Z) -> U3_gga(X, Y, Z, le_in_gga(s(Y), X, B)) le_in_gga(0, Y, true) -> le_out_gga(0, Y, true) le_in_gga(s(X), 0, false) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y), B) -> U1_gga(X, Y, B, le_in_gga(X, Y, B)) U1_gga(X, Y, B, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) U3_gga(X, Y, Z, le_out_gga(s(Y), X, B)) -> U4_gga(X, Y, Z, if_in_ggga(B, X, s(Y), Z)) if_in_ggga(false, X, s(Y), 0) -> if_out_ggga(false, X, s(Y), 0) if_in_ggga(true, X, s(Y), s(Z)) -> U5_ggga(X, Y, Z, minus_in_gga(X, Y, U)) minus_in_gga(X, 0, X) -> minus_out_gga(X, 0, X) minus_in_gga(s(X), s(Y), Z) -> U2_gga(X, Y, Z, minus_in_gga(X, Y, Z)) U2_gga(X, Y, Z, minus_out_gga(X, Y, Z)) -> minus_out_gga(s(X), s(Y), Z) U5_ggga(X, Y, Z, minus_out_gga(X, Y, U)) -> U6_ggga(X, Y, Z, div_in_gga(U, s(Y), Z)) U6_ggga(X, Y, Z, div_out_gga(U, s(Y), Z)) -> if_out_ggga(true, X, s(Y), s(Z)) U4_gga(X, Y, Z, if_out_ggga(B, X, s(Y), Z)) -> div_out_gga(X, s(Y), Z) The argument filtering Pi contains the following mapping: div_in_gga(x1, x2, x3) = div_in_gga(x1, x2) s(x1) = s(x1) U3_gga(x1, x2, x3, x4) = U3_gga(x1, x2, x4) le_in_gga(x1, x2, x3) = le_in_gga(x1, x2) 0 = 0 le_out_gga(x1, x2, x3) = le_out_gga(x1, x2, x3) U1_gga(x1, x2, x3, x4) = U1_gga(x1, x2, x4) U4_gga(x1, x2, x3, x4) = U4_gga(x1, x2, x4) if_in_ggga(x1, x2, x3, x4) = if_in_ggga(x1, x2, x3) false = false if_out_ggga(x1, x2, x3, x4) = if_out_ggga(x1, x2, x3, x4) true = true U5_ggga(x1, x2, x3, x4) = U5_ggga(x1, x2, x4) minus_in_gga(x1, x2, x3) = minus_in_gga(x1, x2) minus_out_gga(x1, x2, x3) = minus_out_gga(x1, x2, x3) U2_gga(x1, x2, x3, x4) = U2_gga(x1, x2, x4) U6_ggga(x1, x2, x3, x4) = U6_ggga(x1, x2, x4) div_out_gga(x1, x2, x3) = div_out_gga(x1, x2, x3) DIV_IN_GGA(x1, x2, x3) = DIV_IN_GGA(x1, x2) U3_GGA(x1, x2, x3, x4) = U3_GGA(x1, x2, x4) LE_IN_GGA(x1, x2, x3) = LE_IN_GGA(x1, x2) U1_GGA(x1, x2, x3, x4) = U1_GGA(x1, x2, x4) U4_GGA(x1, x2, x3, x4) = U4_GGA(x1, x2, x4) IF_IN_GGGA(x1, x2, x3, x4) = IF_IN_GGGA(x1, x2, x3) U5_GGGA(x1, x2, x3, x4) = U5_GGGA(x1, x2, x4) MINUS_IN_GGA(x1, x2, x3) = MINUS_IN_GGA(x1, x2) U2_GGA(x1, x2, x3, x4) = U2_GGA(x1, x2, x4) U6_GGGA(x1, x2, x3, x4) = U6_GGGA(x1, x2, x4) We have to consider all (P,R,Pi)-chains ---------------------------------------- (5) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LOPSTR] contains 3 SCCs with 6 less nodes. ---------------------------------------- (6) Complex Obligation (AND) ---------------------------------------- (7) Obligation: Pi DP problem: The TRS P consists of the following rules: MINUS_IN_GGA(s(X), s(Y), Z) -> MINUS_IN_GGA(X, Y, Z) The TRS R consists of the following rules: div_in_gga(X, s(Y), Z) -> U3_gga(X, Y, Z, le_in_gga(s(Y), X, B)) le_in_gga(0, Y, true) -> le_out_gga(0, Y, true) le_in_gga(s(X), 0, false) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y), B) -> U1_gga(X, Y, B, le_in_gga(X, Y, B)) U1_gga(X, Y, B, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) U3_gga(X, Y, Z, le_out_gga(s(Y), X, B)) -> U4_gga(X, Y, Z, if_in_ggga(B, X, s(Y), Z)) if_in_ggga(false, X, s(Y), 0) -> if_out_ggga(false, X, s(Y), 0) if_in_ggga(true, X, s(Y), s(Z)) -> U5_ggga(X, Y, Z, minus_in_gga(X, Y, U)) minus_in_gga(X, 0, X) -> minus_out_gga(X, 0, X) minus_in_gga(s(X), s(Y), Z) -> U2_gga(X, Y, Z, minus_in_gga(X, Y, Z)) U2_gga(X, Y, Z, minus_out_gga(X, Y, Z)) -> minus_out_gga(s(X), s(Y), Z) U5_ggga(X, Y, Z, minus_out_gga(X, Y, U)) -> U6_ggga(X, Y, Z, div_in_gga(U, s(Y), Z)) U6_ggga(X, Y, Z, div_out_gga(U, s(Y), Z)) -> if_out_ggga(true, X, s(Y), s(Z)) U4_gga(X, Y, Z, if_out_ggga(B, X, s(Y), Z)) -> div_out_gga(X, s(Y), Z) The argument filtering Pi contains the following mapping: div_in_gga(x1, x2, x3) = div_in_gga(x1, x2) s(x1) = s(x1) U3_gga(x1, x2, x3, x4) = U3_gga(x1, x2, x4) le_in_gga(x1, x2, x3) = le_in_gga(x1, x2) 0 = 0 le_out_gga(x1, x2, x3) = le_out_gga(x1, x2, x3) U1_gga(x1, x2, x3, x4) = U1_gga(x1, x2, x4) U4_gga(x1, x2, x3, x4) = U4_gga(x1, x2, x4) if_in_ggga(x1, x2, x3, x4) = if_in_ggga(x1, x2, x3) false = false if_out_ggga(x1, x2, x3, x4) = if_out_ggga(x1, x2, x3, x4) true = true U5_ggga(x1, x2, x3, x4) = U5_ggga(x1, x2, x4) minus_in_gga(x1, x2, x3) = minus_in_gga(x1, x2) minus_out_gga(x1, x2, x3) = minus_out_gga(x1, x2, x3) U2_gga(x1, x2, x3, x4) = U2_gga(x1, x2, x4) U6_ggga(x1, x2, x3, x4) = U6_ggga(x1, x2, x4) div_out_gga(x1, x2, x3) = div_out_gga(x1, x2, x3) MINUS_IN_GGA(x1, x2, x3) = MINUS_IN_GGA(x1, x2) We have to consider all (P,R,Pi)-chains ---------------------------------------- (8) UsableRulesProof (EQUIVALENT) For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R. ---------------------------------------- (9) Obligation: Pi DP problem: The TRS P consists of the following rules: MINUS_IN_GGA(s(X), s(Y), Z) -> MINUS_IN_GGA(X, Y, Z) R is empty. The argument filtering Pi contains the following mapping: s(x1) = s(x1) MINUS_IN_GGA(x1, x2, x3) = MINUS_IN_GGA(x1, x2) We have to consider all (P,R,Pi)-chains ---------------------------------------- (10) PiDPToQDPProof (SOUND) Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi. ---------------------------------------- (11) Obligation: Q DP problem: The TRS P consists of the following rules: MINUS_IN_GGA(s(X), s(Y)) -> MINUS_IN_GGA(X, Y) R is empty. Q is empty. We have to consider all (P,Q,R)-chains. ---------------------------------------- (12) 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: *MINUS_IN_GGA(s(X), s(Y)) -> MINUS_IN_GGA(X, Y) The graph contains the following edges 1 > 1, 2 > 2 ---------------------------------------- (13) YES ---------------------------------------- (14) Obligation: Pi DP problem: The TRS P consists of the following rules: LE_IN_GGA(s(X), s(Y), B) -> LE_IN_GGA(X, Y, B) The TRS R consists of the following rules: div_in_gga(X, s(Y), Z) -> U3_gga(X, Y, Z, le_in_gga(s(Y), X, B)) le_in_gga(0, Y, true) -> le_out_gga(0, Y, true) le_in_gga(s(X), 0, false) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y), B) -> U1_gga(X, Y, B, le_in_gga(X, Y, B)) U1_gga(X, Y, B, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) U3_gga(X, Y, Z, le_out_gga(s(Y), X, B)) -> U4_gga(X, Y, Z, if_in_ggga(B, X, s(Y), Z)) if_in_ggga(false, X, s(Y), 0) -> if_out_ggga(false, X, s(Y), 0) if_in_ggga(true, X, s(Y), s(Z)) -> U5_ggga(X, Y, Z, minus_in_gga(X, Y, U)) minus_in_gga(X, 0, X) -> minus_out_gga(X, 0, X) minus_in_gga(s(X), s(Y), Z) -> U2_gga(X, Y, Z, minus_in_gga(X, Y, Z)) U2_gga(X, Y, Z, minus_out_gga(X, Y, Z)) -> minus_out_gga(s(X), s(Y), Z) U5_ggga(X, Y, Z, minus_out_gga(X, Y, U)) -> U6_ggga(X, Y, Z, div_in_gga(U, s(Y), Z)) U6_ggga(X, Y, Z, div_out_gga(U, s(Y), Z)) -> if_out_ggga(true, X, s(Y), s(Z)) U4_gga(X, Y, Z, if_out_ggga(B, X, s(Y), Z)) -> div_out_gga(X, s(Y), Z) The argument filtering Pi contains the following mapping: div_in_gga(x1, x2, x3) = div_in_gga(x1, x2) s(x1) = s(x1) U3_gga(x1, x2, x3, x4) = U3_gga(x1, x2, x4) le_in_gga(x1, x2, x3) = le_in_gga(x1, x2) 0 = 0 le_out_gga(x1, x2, x3) = le_out_gga(x1, x2, x3) U1_gga(x1, x2, x3, x4) = U1_gga(x1, x2, x4) U4_gga(x1, x2, x3, x4) = U4_gga(x1, x2, x4) if_in_ggga(x1, x2, x3, x4) = if_in_ggga(x1, x2, x3) false = false if_out_ggga(x1, x2, x3, x4) = if_out_ggga(x1, x2, x3, x4) true = true U5_ggga(x1, x2, x3, x4) = U5_ggga(x1, x2, x4) minus_in_gga(x1, x2, x3) = minus_in_gga(x1, x2) minus_out_gga(x1, x2, x3) = minus_out_gga(x1, x2, x3) U2_gga(x1, x2, x3, x4) = U2_gga(x1, x2, x4) U6_ggga(x1, x2, x3, x4) = U6_ggga(x1, x2, x4) div_out_gga(x1, x2, x3) = div_out_gga(x1, x2, x3) LE_IN_GGA(x1, x2, x3) = LE_IN_GGA(x1, x2) We have to consider all (P,R,Pi)-chains ---------------------------------------- (15) UsableRulesProof (EQUIVALENT) For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R. ---------------------------------------- (16) Obligation: Pi DP problem: The TRS P consists of the following rules: LE_IN_GGA(s(X), s(Y), B) -> LE_IN_GGA(X, Y, B) R is empty. The argument filtering Pi contains the following mapping: s(x1) = s(x1) LE_IN_GGA(x1, x2, x3) = LE_IN_GGA(x1, x2) We have to consider all (P,R,Pi)-chains ---------------------------------------- (17) PiDPToQDPProof (SOUND) Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi. ---------------------------------------- (18) Obligation: Q DP problem: The TRS P consists of the following rules: LE_IN_GGA(s(X), s(Y)) -> LE_IN_GGA(X, Y) R is empty. Q is empty. We have to consider all (P,Q,R)-chains. ---------------------------------------- (19) QDPSizeChangeProof (EQUIVALENT) By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. From the DPs we obtained the following set of size-change graphs: *LE_IN_GGA(s(X), s(Y)) -> LE_IN_GGA(X, Y) The graph contains the following edges 1 > 1, 2 > 2 ---------------------------------------- (20) YES ---------------------------------------- (21) Obligation: Pi DP problem: The TRS P consists of the following rules: U3_GGA(X, Y, Z, le_out_gga(s(Y), X, B)) -> IF_IN_GGGA(B, X, s(Y), Z) IF_IN_GGGA(true, X, s(Y), s(Z)) -> U5_GGGA(X, Y, Z, minus_in_gga(X, Y, U)) U5_GGGA(X, Y, Z, minus_out_gga(X, Y, U)) -> DIV_IN_GGA(U, s(Y), Z) DIV_IN_GGA(X, s(Y), Z) -> U3_GGA(X, Y, Z, le_in_gga(s(Y), X, B)) The TRS R consists of the following rules: div_in_gga(X, s(Y), Z) -> U3_gga(X, Y, Z, le_in_gga(s(Y), X, B)) le_in_gga(0, Y, true) -> le_out_gga(0, Y, true) le_in_gga(s(X), 0, false) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y), B) -> U1_gga(X, Y, B, le_in_gga(X, Y, B)) U1_gga(X, Y, B, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) U3_gga(X, Y, Z, le_out_gga(s(Y), X, B)) -> U4_gga(X, Y, Z, if_in_ggga(B, X, s(Y), Z)) if_in_ggga(false, X, s(Y), 0) -> if_out_ggga(false, X, s(Y), 0) if_in_ggga(true, X, s(Y), s(Z)) -> U5_ggga(X, Y, Z, minus_in_gga(X, Y, U)) minus_in_gga(X, 0, X) -> minus_out_gga(X, 0, X) minus_in_gga(s(X), s(Y), Z) -> U2_gga(X, Y, Z, minus_in_gga(X, Y, Z)) U2_gga(X, Y, Z, minus_out_gga(X, Y, Z)) -> minus_out_gga(s(X), s(Y), Z) U5_ggga(X, Y, Z, minus_out_gga(X, Y, U)) -> U6_ggga(X, Y, Z, div_in_gga(U, s(Y), Z)) U6_ggga(X, Y, Z, div_out_gga(U, s(Y), Z)) -> if_out_ggga(true, X, s(Y), s(Z)) U4_gga(X, Y, Z, if_out_ggga(B, X, s(Y), Z)) -> div_out_gga(X, s(Y), Z) The argument filtering Pi contains the following mapping: div_in_gga(x1, x2, x3) = div_in_gga(x1, x2) s(x1) = s(x1) U3_gga(x1, x2, x3, x4) = U3_gga(x1, x2, x4) le_in_gga(x1, x2, x3) = le_in_gga(x1, x2) 0 = 0 le_out_gga(x1, x2, x3) = le_out_gga(x1, x2, x3) U1_gga(x1, x2, x3, x4) = U1_gga(x1, x2, x4) U4_gga(x1, x2, x3, x4) = U4_gga(x1, x2, x4) if_in_ggga(x1, x2, x3, x4) = if_in_ggga(x1, x2, x3) false = false if_out_ggga(x1, x2, x3, x4) = if_out_ggga(x1, x2, x3, x4) true = true U5_ggga(x1, x2, x3, x4) = U5_ggga(x1, x2, x4) minus_in_gga(x1, x2, x3) = minus_in_gga(x1, x2) minus_out_gga(x1, x2, x3) = minus_out_gga(x1, x2, x3) U2_gga(x1, x2, x3, x4) = U2_gga(x1, x2, x4) U6_ggga(x1, x2, x3, x4) = U6_ggga(x1, x2, x4) div_out_gga(x1, x2, x3) = div_out_gga(x1, x2, x3) DIV_IN_GGA(x1, x2, x3) = DIV_IN_GGA(x1, x2) U3_GGA(x1, x2, x3, x4) = U3_GGA(x1, x2, x4) IF_IN_GGGA(x1, x2, x3, x4) = IF_IN_GGGA(x1, x2, x3) U5_GGGA(x1, x2, x3, x4) = U5_GGGA(x1, x2, x4) We have to consider all (P,R,Pi)-chains ---------------------------------------- (22) UsableRulesProof (EQUIVALENT) For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R. ---------------------------------------- (23) Obligation: Pi DP problem: The TRS P consists of the following rules: U3_GGA(X, Y, Z, le_out_gga(s(Y), X, B)) -> IF_IN_GGGA(B, X, s(Y), Z) IF_IN_GGGA(true, X, s(Y), s(Z)) -> U5_GGGA(X, Y, Z, minus_in_gga(X, Y, U)) U5_GGGA(X, Y, Z, minus_out_gga(X, Y, U)) -> DIV_IN_GGA(U, s(Y), Z) DIV_IN_GGA(X, s(Y), Z) -> U3_GGA(X, Y, Z, le_in_gga(s(Y), X, B)) The TRS R consists of the following rules: minus_in_gga(X, 0, X) -> minus_out_gga(X, 0, X) minus_in_gga(s(X), s(Y), Z) -> U2_gga(X, Y, Z, minus_in_gga(X, Y, Z)) le_in_gga(s(X), 0, false) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y), B) -> U1_gga(X, Y, B, le_in_gga(X, Y, B)) U2_gga(X, Y, Z, minus_out_gga(X, Y, Z)) -> minus_out_gga(s(X), s(Y), Z) U1_gga(X, Y, B, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) le_in_gga(0, Y, true) -> le_out_gga(0, Y, true) The argument filtering Pi contains the following mapping: s(x1) = s(x1) le_in_gga(x1, x2, x3) = le_in_gga(x1, x2) 0 = 0 le_out_gga(x1, x2, x3) = le_out_gga(x1, x2, x3) U1_gga(x1, x2, x3, x4) = U1_gga(x1, x2, x4) false = false true = true minus_in_gga(x1, x2, x3) = minus_in_gga(x1, x2) minus_out_gga(x1, x2, x3) = minus_out_gga(x1, x2, x3) U2_gga(x1, x2, x3, x4) = U2_gga(x1, x2, x4) DIV_IN_GGA(x1, x2, x3) = DIV_IN_GGA(x1, x2) U3_GGA(x1, x2, x3, x4) = U3_GGA(x1, x2, x4) IF_IN_GGGA(x1, x2, x3, x4) = IF_IN_GGGA(x1, x2, x3) U5_GGGA(x1, x2, x3, x4) = U5_GGGA(x1, x2, x4) We have to consider all (P,R,Pi)-chains ---------------------------------------- (24) PiDPToQDPProof (SOUND) Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi. ---------------------------------------- (25) Obligation: Q DP problem: The TRS P consists of the following rules: U3_GGA(X, Y, le_out_gga(s(Y), X, B)) -> IF_IN_GGGA(B, X, s(Y)) IF_IN_GGGA(true, X, s(Y)) -> U5_GGGA(X, Y, minus_in_gga(X, Y)) U5_GGGA(X, Y, minus_out_gga(X, Y, U)) -> DIV_IN_GGA(U, s(Y)) DIV_IN_GGA(X, s(Y)) -> U3_GGA(X, Y, le_in_gga(s(Y), X)) The TRS R consists of the following rules: minus_in_gga(X, 0) -> minus_out_gga(X, 0, X) minus_in_gga(s(X), s(Y)) -> U2_gga(X, Y, minus_in_gga(X, Y)) le_in_gga(s(X), 0) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y)) -> U1_gga(X, Y, le_in_gga(X, Y)) U2_gga(X, Y, minus_out_gga(X, Y, Z)) -> minus_out_gga(s(X), s(Y), Z) U1_gga(X, Y, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) le_in_gga(0, Y) -> le_out_gga(0, Y, true) The set Q consists of the following terms: minus_in_gga(x0, x1) le_in_gga(x0, x1) U2_gga(x0, x1, x2) U1_gga(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (26) QDPQMonotonicMRRProof (EQUIVALENT) By using the Q-monotonic rule removal processor with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented such that it always occurs at a strongly monotonic position in a (P,Q,R)-chain. Strictly oriented rules of the TRS R: minus_in_gga(s(X), s(Y)) -> U2_gga(X, Y, minus_in_gga(X, Y)) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(DIV_IN_GGA(x_1, x_2)) = 2*x_1 POL(IF_IN_GGGA(x_1, x_2, x_3)) = 2*x_2 POL(U1_gga(x_1, x_2, x_3)) = 0 POL(U2_gga(x_1, x_2, x_3)) = x_3 POL(U3_GGA(x_1, x_2, x_3)) = 2*x_1 POL(U5_GGGA(x_1, x_2, x_3)) = 2*x_3 POL(false) = 2 POL(le_in_gga(x_1, x_2)) = 0 POL(le_out_gga(x_1, x_2, x_3)) = 0 POL(minus_in_gga(x_1, x_2)) = x_1 POL(minus_out_gga(x_1, x_2, x_3)) = x_3 POL(s(x_1)) = 2 + x_1 POL(true) = 0 ---------------------------------------- (27) Obligation: Q DP problem: The TRS P consists of the following rules: U3_GGA(X, Y, le_out_gga(s(Y), X, B)) -> IF_IN_GGGA(B, X, s(Y)) IF_IN_GGGA(true, X, s(Y)) -> U5_GGGA(X, Y, minus_in_gga(X, Y)) U5_GGGA(X, Y, minus_out_gga(X, Y, U)) -> DIV_IN_GGA(U, s(Y)) DIV_IN_GGA(X, s(Y)) -> U3_GGA(X, Y, le_in_gga(s(Y), X)) The TRS R consists of the following rules: minus_in_gga(X, 0) -> minus_out_gga(X, 0, X) le_in_gga(s(X), 0) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y)) -> U1_gga(X, Y, le_in_gga(X, Y)) U2_gga(X, Y, minus_out_gga(X, Y, Z)) -> minus_out_gga(s(X), s(Y), Z) U1_gga(X, Y, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) le_in_gga(0, Y) -> le_out_gga(0, Y, true) The set Q consists of the following terms: minus_in_gga(x0, x1) le_in_gga(x0, x1) U2_gga(x0, x1, x2) U1_gga(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (28) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (29) Obligation: Q DP problem: The TRS P consists of the following rules: U3_GGA(X, Y, le_out_gga(s(Y), X, B)) -> IF_IN_GGGA(B, X, s(Y)) IF_IN_GGGA(true, X, s(Y)) -> U5_GGGA(X, Y, minus_in_gga(X, Y)) U5_GGGA(X, Y, minus_out_gga(X, Y, U)) -> DIV_IN_GGA(U, s(Y)) DIV_IN_GGA(X, s(Y)) -> U3_GGA(X, Y, le_in_gga(s(Y), X)) The TRS R consists of the following rules: le_in_gga(s(X), 0) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y)) -> U1_gga(X, Y, le_in_gga(X, Y)) le_in_gga(0, Y) -> le_out_gga(0, Y, true) U1_gga(X, Y, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) minus_in_gga(X, 0) -> minus_out_gga(X, 0, X) The set Q consists of the following terms: minus_in_gga(x0, x1) le_in_gga(x0, x1) U2_gga(x0, x1, x2) U1_gga(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (30) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. U2_gga(x0, x1, x2) ---------------------------------------- (31) Obligation: Q DP problem: The TRS P consists of the following rules: U3_GGA(X, Y, le_out_gga(s(Y), X, B)) -> IF_IN_GGGA(B, X, s(Y)) IF_IN_GGGA(true, X, s(Y)) -> U5_GGGA(X, Y, minus_in_gga(X, Y)) U5_GGGA(X, Y, minus_out_gga(X, Y, U)) -> DIV_IN_GGA(U, s(Y)) DIV_IN_GGA(X, s(Y)) -> U3_GGA(X, Y, le_in_gga(s(Y), X)) The TRS R consists of the following rules: le_in_gga(s(X), 0) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y)) -> U1_gga(X, Y, le_in_gga(X, Y)) le_in_gga(0, Y) -> le_out_gga(0, Y, true) U1_gga(X, Y, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) minus_in_gga(X, 0) -> minus_out_gga(X, 0, X) The set Q consists of the following terms: minus_in_gga(x0, x1) le_in_gga(x0, x1) U1_gga(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (32) TransformationProof (SOUND) By narrowing [LPAR04] the rule IF_IN_GGGA(true, X, s(Y)) -> U5_GGGA(X, Y, minus_in_gga(X, Y)) at position [2] we obtained the following new rules [LPAR04]: (IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(x0, 0, minus_out_gga(x0, 0, x0)),IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(x0, 0, minus_out_gga(x0, 0, x0))) ---------------------------------------- (33) Obligation: Q DP problem: The TRS P consists of the following rules: U3_GGA(X, Y, le_out_gga(s(Y), X, B)) -> IF_IN_GGGA(B, X, s(Y)) U5_GGGA(X, Y, minus_out_gga(X, Y, U)) -> DIV_IN_GGA(U, s(Y)) DIV_IN_GGA(X, s(Y)) -> U3_GGA(X, Y, le_in_gga(s(Y), X)) IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(x0, 0, minus_out_gga(x0, 0, x0)) The TRS R consists of the following rules: le_in_gga(s(X), 0) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y)) -> U1_gga(X, Y, le_in_gga(X, Y)) le_in_gga(0, Y) -> le_out_gga(0, Y, true) U1_gga(X, Y, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) minus_in_gga(X, 0) -> minus_out_gga(X, 0, X) The set Q consists of the following terms: minus_in_gga(x0, x1) le_in_gga(x0, x1) U1_gga(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (34) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (35) Obligation: Q DP problem: The TRS P consists of the following rules: U3_GGA(X, Y, le_out_gga(s(Y), X, B)) -> IF_IN_GGGA(B, X, s(Y)) U5_GGGA(X, Y, minus_out_gga(X, Y, U)) -> DIV_IN_GGA(U, s(Y)) DIV_IN_GGA(X, s(Y)) -> U3_GGA(X, Y, le_in_gga(s(Y), X)) IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(x0, 0, minus_out_gga(x0, 0, x0)) The TRS R consists of the following rules: le_in_gga(s(X), 0) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y)) -> U1_gga(X, Y, le_in_gga(X, Y)) le_in_gga(0, Y) -> le_out_gga(0, Y, true) U1_gga(X, Y, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) The set Q consists of the following terms: minus_in_gga(x0, x1) le_in_gga(x0, x1) U1_gga(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (36) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. minus_in_gga(x0, x1) ---------------------------------------- (37) Obligation: Q DP problem: The TRS P consists of the following rules: U3_GGA(X, Y, le_out_gga(s(Y), X, B)) -> IF_IN_GGGA(B, X, s(Y)) U5_GGGA(X, Y, minus_out_gga(X, Y, U)) -> DIV_IN_GGA(U, s(Y)) DIV_IN_GGA(X, s(Y)) -> U3_GGA(X, Y, le_in_gga(s(Y), X)) IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(x0, 0, minus_out_gga(x0, 0, x0)) The TRS R consists of the following rules: le_in_gga(s(X), 0) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y)) -> U1_gga(X, Y, le_in_gga(X, Y)) le_in_gga(0, Y) -> le_out_gga(0, Y, true) U1_gga(X, Y, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) The set Q consists of the following terms: le_in_gga(x0, x1) U1_gga(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (38) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule U5_GGGA(X, Y, minus_out_gga(X, Y, U)) -> DIV_IN_GGA(U, s(Y)) we obtained the following new rules [LPAR04]: (U5_GGGA(z0, 0, minus_out_gga(z0, 0, z0)) -> DIV_IN_GGA(z0, s(0)),U5_GGGA(z0, 0, minus_out_gga(z0, 0, z0)) -> DIV_IN_GGA(z0, s(0))) ---------------------------------------- (39) Obligation: Q DP problem: The TRS P consists of the following rules: U3_GGA(X, Y, le_out_gga(s(Y), X, B)) -> IF_IN_GGGA(B, X, s(Y)) DIV_IN_GGA(X, s(Y)) -> U3_GGA(X, Y, le_in_gga(s(Y), X)) IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(x0, 0, minus_out_gga(x0, 0, x0)) U5_GGGA(z0, 0, minus_out_gga(z0, 0, z0)) -> DIV_IN_GGA(z0, s(0)) The TRS R consists of the following rules: le_in_gga(s(X), 0) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y)) -> U1_gga(X, Y, le_in_gga(X, Y)) le_in_gga(0, Y) -> le_out_gga(0, Y, true) U1_gga(X, Y, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) The set Q consists of the following terms: le_in_gga(x0, x1) U1_gga(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (40) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule DIV_IN_GGA(X, s(Y)) -> U3_GGA(X, Y, le_in_gga(s(Y), X)) we obtained the following new rules [LPAR04]: (DIV_IN_GGA(z0, s(0)) -> U3_GGA(z0, 0, le_in_gga(s(0), z0)),DIV_IN_GGA(z0, s(0)) -> U3_GGA(z0, 0, le_in_gga(s(0), z0))) ---------------------------------------- (41) Obligation: Q DP problem: The TRS P consists of the following rules: U3_GGA(X, Y, le_out_gga(s(Y), X, B)) -> IF_IN_GGGA(B, X, s(Y)) IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(x0, 0, minus_out_gga(x0, 0, x0)) U5_GGGA(z0, 0, minus_out_gga(z0, 0, z0)) -> DIV_IN_GGA(z0, s(0)) DIV_IN_GGA(z0, s(0)) -> U3_GGA(z0, 0, le_in_gga(s(0), z0)) The TRS R consists of the following rules: le_in_gga(s(X), 0) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y)) -> U1_gga(X, Y, le_in_gga(X, Y)) le_in_gga(0, Y) -> le_out_gga(0, Y, true) U1_gga(X, Y, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) The set Q consists of the following terms: le_in_gga(x0, x1) U1_gga(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (42) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule U3_GGA(X, Y, le_out_gga(s(Y), X, B)) -> IF_IN_GGGA(B, X, s(Y)) we obtained the following new rules [LPAR04]: (U3_GGA(z0, 0, le_out_gga(s(0), z0, x2)) -> IF_IN_GGGA(x2, z0, s(0)),U3_GGA(z0, 0, le_out_gga(s(0), z0, x2)) -> IF_IN_GGGA(x2, z0, s(0))) ---------------------------------------- (43) Obligation: Q DP problem: The TRS P consists of the following rules: IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(x0, 0, minus_out_gga(x0, 0, x0)) U5_GGGA(z0, 0, minus_out_gga(z0, 0, z0)) -> DIV_IN_GGA(z0, s(0)) DIV_IN_GGA(z0, s(0)) -> U3_GGA(z0, 0, le_in_gga(s(0), z0)) U3_GGA(z0, 0, le_out_gga(s(0), z0, x2)) -> IF_IN_GGGA(x2, z0, s(0)) The TRS R consists of the following rules: le_in_gga(s(X), 0) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y)) -> U1_gga(X, Y, le_in_gga(X, Y)) le_in_gga(0, Y) -> le_out_gga(0, Y, true) U1_gga(X, Y, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) The set Q consists of the following terms: le_in_gga(x0, x1) U1_gga(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (44) QDPQMonotonicMRRProof (EQUIVALENT) By using the Q-monotonic rule removal processor with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented such that it always occurs at a strongly monotonic position in a (P,Q,R)-chain. Strictly oriented rules of the TRS R: le_in_gga(s(X), 0) -> le_out_gga(s(X), 0, false) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(DIV_IN_GGA(x_1, x_2)) = 2 POL(IF_IN_GGGA(x_1, x_2, x_3)) = 2*x_1 POL(U1_gga(x_1, x_2, x_3)) = x_3 POL(U3_GGA(x_1, x_2, x_3)) = 2*x_2 + 2*x_3 POL(U5_GGGA(x_1, x_2, x_3)) = x_2 + x_3 POL(false) = 0 POL(le_in_gga(x_1, x_2)) = 1 POL(le_out_gga(x_1, x_2, x_3)) = x_3 POL(minus_out_gga(x_1, x_2, x_3)) = 2 POL(s(x_1)) = 0 POL(true) = 1 ---------------------------------------- (45) Obligation: Q DP problem: The TRS P consists of the following rules: IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(x0, 0, minus_out_gga(x0, 0, x0)) U5_GGGA(z0, 0, minus_out_gga(z0, 0, z0)) -> DIV_IN_GGA(z0, s(0)) DIV_IN_GGA(z0, s(0)) -> U3_GGA(z0, 0, le_in_gga(s(0), z0)) U3_GGA(z0, 0, le_out_gga(s(0), z0, x2)) -> IF_IN_GGGA(x2, z0, s(0)) The TRS R consists of the following rules: le_in_gga(s(X), s(Y)) -> U1_gga(X, Y, le_in_gga(X, Y)) le_in_gga(0, Y) -> le_out_gga(0, Y, true) U1_gga(X, Y, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) The set Q consists of the following terms: le_in_gga(x0, x1) U1_gga(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (46) TransformationProof (SOUND) By narrowing [LPAR04] the rule DIV_IN_GGA(z0, s(0)) -> U3_GGA(z0, 0, le_in_gga(s(0), z0)) at position [2] we obtained the following new rules [LPAR04]: (DIV_IN_GGA(s(x1), s(0)) -> U3_GGA(s(x1), 0, U1_gga(0, x1, le_in_gga(0, x1))),DIV_IN_GGA(s(x1), s(0)) -> U3_GGA(s(x1), 0, U1_gga(0, x1, le_in_gga(0, x1)))) ---------------------------------------- (47) Obligation: Q DP problem: The TRS P consists of the following rules: IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(x0, 0, minus_out_gga(x0, 0, x0)) U5_GGGA(z0, 0, minus_out_gga(z0, 0, z0)) -> DIV_IN_GGA(z0, s(0)) U3_GGA(z0, 0, le_out_gga(s(0), z0, x2)) -> IF_IN_GGGA(x2, z0, s(0)) DIV_IN_GGA(s(x1), s(0)) -> U3_GGA(s(x1), 0, U1_gga(0, x1, le_in_gga(0, x1))) The TRS R consists of the following rules: le_in_gga(s(X), s(Y)) -> U1_gga(X, Y, le_in_gga(X, Y)) le_in_gga(0, Y) -> le_out_gga(0, Y, true) U1_gga(X, Y, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) The set Q consists of the following terms: le_in_gga(x0, x1) U1_gga(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (48) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (49) Obligation: Q DP problem: The TRS P consists of the following rules: IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(x0, 0, minus_out_gga(x0, 0, x0)) U5_GGGA(z0, 0, minus_out_gga(z0, 0, z0)) -> DIV_IN_GGA(z0, s(0)) U3_GGA(z0, 0, le_out_gga(s(0), z0, x2)) -> IF_IN_GGGA(x2, z0, s(0)) DIV_IN_GGA(s(x1), s(0)) -> U3_GGA(s(x1), 0, U1_gga(0, x1, le_in_gga(0, x1))) The TRS R consists of the following rules: le_in_gga(0, Y) -> le_out_gga(0, Y, true) U1_gga(X, Y, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) The set Q consists of the following terms: le_in_gga(x0, x1) U1_gga(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (50) TransformationProof (EQUIVALENT) By rewriting [LPAR04] the rule DIV_IN_GGA(s(x1), s(0)) -> U3_GGA(s(x1), 0, U1_gga(0, x1, le_in_gga(0, x1))) at position [2,2] we obtained the following new rules [LPAR04]: (DIV_IN_GGA(s(x1), s(0)) -> U3_GGA(s(x1), 0, U1_gga(0, x1, le_out_gga(0, x1, true))),DIV_IN_GGA(s(x1), s(0)) -> U3_GGA(s(x1), 0, U1_gga(0, x1, le_out_gga(0, x1, true)))) ---------------------------------------- (51) Obligation: Q DP problem: The TRS P consists of the following rules: IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(x0, 0, minus_out_gga(x0, 0, x0)) U5_GGGA(z0, 0, minus_out_gga(z0, 0, z0)) -> DIV_IN_GGA(z0, s(0)) U3_GGA(z0, 0, le_out_gga(s(0), z0, x2)) -> IF_IN_GGGA(x2, z0, s(0)) DIV_IN_GGA(s(x1), s(0)) -> U3_GGA(s(x1), 0, U1_gga(0, x1, le_out_gga(0, x1, true))) The TRS R consists of the following rules: le_in_gga(0, Y) -> le_out_gga(0, Y, true) U1_gga(X, Y, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) The set Q consists of the following terms: le_in_gga(x0, x1) U1_gga(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (52) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (53) Obligation: Q DP problem: The TRS P consists of the following rules: IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(x0, 0, minus_out_gga(x0, 0, x0)) U5_GGGA(z0, 0, minus_out_gga(z0, 0, z0)) -> DIV_IN_GGA(z0, s(0)) U3_GGA(z0, 0, le_out_gga(s(0), z0, x2)) -> IF_IN_GGGA(x2, z0, s(0)) DIV_IN_GGA(s(x1), s(0)) -> U3_GGA(s(x1), 0, U1_gga(0, x1, le_out_gga(0, x1, true))) The TRS R consists of the following rules: U1_gga(X, Y, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) The set Q consists of the following terms: le_in_gga(x0, x1) U1_gga(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (54) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. le_in_gga(x0, x1) ---------------------------------------- (55) Obligation: Q DP problem: The TRS P consists of the following rules: IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(x0, 0, minus_out_gga(x0, 0, x0)) U5_GGGA(z0, 0, minus_out_gga(z0, 0, z0)) -> DIV_IN_GGA(z0, s(0)) U3_GGA(z0, 0, le_out_gga(s(0), z0, x2)) -> IF_IN_GGGA(x2, z0, s(0)) DIV_IN_GGA(s(x1), s(0)) -> U3_GGA(s(x1), 0, U1_gga(0, x1, le_out_gga(0, x1, true))) The TRS R consists of the following rules: U1_gga(X, Y, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) The set Q consists of the following terms: U1_gga(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (56) TransformationProof (EQUIVALENT) By rewriting [LPAR04] the rule DIV_IN_GGA(s(x1), s(0)) -> U3_GGA(s(x1), 0, U1_gga(0, x1, le_out_gga(0, x1, true))) at position [2] we obtained the following new rules [LPAR04]: (DIV_IN_GGA(s(x1), s(0)) -> U3_GGA(s(x1), 0, le_out_gga(s(0), s(x1), true)),DIV_IN_GGA(s(x1), s(0)) -> U3_GGA(s(x1), 0, le_out_gga(s(0), s(x1), true))) ---------------------------------------- (57) Obligation: Q DP problem: The TRS P consists of the following rules: IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(x0, 0, minus_out_gga(x0, 0, x0)) U5_GGGA(z0, 0, minus_out_gga(z0, 0, z0)) -> DIV_IN_GGA(z0, s(0)) U3_GGA(z0, 0, le_out_gga(s(0), z0, x2)) -> IF_IN_GGGA(x2, z0, s(0)) DIV_IN_GGA(s(x1), s(0)) -> U3_GGA(s(x1), 0, le_out_gga(s(0), s(x1), true)) The TRS R consists of the following rules: U1_gga(X, Y, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) The set Q consists of the following terms: U1_gga(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (58) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (59) Obligation: Q DP problem: The TRS P consists of the following rules: IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(x0, 0, minus_out_gga(x0, 0, x0)) U5_GGGA(z0, 0, minus_out_gga(z0, 0, z0)) -> DIV_IN_GGA(z0, s(0)) U3_GGA(z0, 0, le_out_gga(s(0), z0, x2)) -> IF_IN_GGGA(x2, z0, s(0)) DIV_IN_GGA(s(x1), s(0)) -> U3_GGA(s(x1), 0, le_out_gga(s(0), s(x1), true)) R is empty. The set Q consists of the following terms: U1_gga(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (60) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. U1_gga(x0, x1, x2) ---------------------------------------- (61) Obligation: Q DP problem: The TRS P consists of the following rules: IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(x0, 0, minus_out_gga(x0, 0, x0)) U5_GGGA(z0, 0, minus_out_gga(z0, 0, z0)) -> DIV_IN_GGA(z0, s(0)) U3_GGA(z0, 0, le_out_gga(s(0), z0, x2)) -> IF_IN_GGGA(x2, z0, s(0)) DIV_IN_GGA(s(x1), s(0)) -> U3_GGA(s(x1), 0, le_out_gga(s(0), s(x1), true)) R is empty. Q is empty. We have to consider all (P,Q,R)-chains. ---------------------------------------- (62) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule U3_GGA(z0, 0, le_out_gga(s(0), z0, x2)) -> IF_IN_GGGA(x2, z0, s(0)) we obtained the following new rules [LPAR04]: (U3_GGA(s(z0), 0, le_out_gga(s(0), s(z0), true)) -> IF_IN_GGGA(true, s(z0), s(0)),U3_GGA(s(z0), 0, le_out_gga(s(0), s(z0), true)) -> IF_IN_GGGA(true, s(z0), s(0))) ---------------------------------------- (63) Obligation: Q DP problem: The TRS P consists of the following rules: IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(x0, 0, minus_out_gga(x0, 0, x0)) U5_GGGA(z0, 0, minus_out_gga(z0, 0, z0)) -> DIV_IN_GGA(z0, s(0)) DIV_IN_GGA(s(x1), s(0)) -> U3_GGA(s(x1), 0, le_out_gga(s(0), s(x1), true)) U3_GGA(s(z0), 0, le_out_gga(s(0), s(z0), true)) -> IF_IN_GGGA(true, s(z0), s(0)) R is empty. Q is empty. We have to consider all (P,Q,R)-chains. ---------------------------------------- (64) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(x0, 0, minus_out_gga(x0, 0, x0)) we obtained the following new rules [LPAR04]: (IF_IN_GGGA(true, s(z0), s(0)) -> U5_GGGA(s(z0), 0, minus_out_gga(s(z0), 0, s(z0))),IF_IN_GGGA(true, s(z0), s(0)) -> U5_GGGA(s(z0), 0, minus_out_gga(s(z0), 0, s(z0)))) ---------------------------------------- (65) Obligation: Q DP problem: The TRS P consists of the following rules: U5_GGGA(z0, 0, minus_out_gga(z0, 0, z0)) -> DIV_IN_GGA(z0, s(0)) DIV_IN_GGA(s(x1), s(0)) -> U3_GGA(s(x1), 0, le_out_gga(s(0), s(x1), true)) U3_GGA(s(z0), 0, le_out_gga(s(0), s(z0), true)) -> IF_IN_GGGA(true, s(z0), s(0)) IF_IN_GGGA(true, s(z0), s(0)) -> U5_GGGA(s(z0), 0, minus_out_gga(s(z0), 0, s(z0))) R is empty. Q is empty. We have to consider all (P,Q,R)-chains. ---------------------------------------- (66) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule U5_GGGA(z0, 0, minus_out_gga(z0, 0, z0)) -> DIV_IN_GGA(z0, s(0)) we obtained the following new rules [LPAR04]: (U5_GGGA(s(z0), 0, minus_out_gga(s(z0), 0, s(z0))) -> DIV_IN_GGA(s(z0), s(0)),U5_GGGA(s(z0), 0, minus_out_gga(s(z0), 0, s(z0))) -> DIV_IN_GGA(s(z0), s(0))) ---------------------------------------- (67) Obligation: Q DP problem: The TRS P consists of the following rules: DIV_IN_GGA(s(x1), s(0)) -> U3_GGA(s(x1), 0, le_out_gga(s(0), s(x1), true)) U3_GGA(s(z0), 0, le_out_gga(s(0), s(z0), true)) -> IF_IN_GGGA(true, s(z0), s(0)) IF_IN_GGGA(true, s(z0), s(0)) -> U5_GGGA(s(z0), 0, minus_out_gga(s(z0), 0, s(z0))) U5_GGGA(s(z0), 0, minus_out_gga(s(z0), 0, s(z0))) -> DIV_IN_GGA(s(z0), s(0)) R is empty. Q is empty. We have to consider all (P,Q,R)-chains. ---------------------------------------- (68) 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 = U3_GGA(s(z0), 0, le_out_gga(s(0), s(z0), true)) evaluates to t =U3_GGA(s(z0), 0, le_out_gga(s(0), s(z0), true)) Thus s starts an infinite chain as s semiunifies with t with the following substitutions: * Matcher: [ ] * Semiunifier: [ ] -------------------------------------------------------------------------------- Rewriting sequence U3_GGA(s(z0), 0, le_out_gga(s(0), s(z0), true)) -> IF_IN_GGGA(true, s(z0), s(0)) with rule U3_GGA(s(z0'), 0, le_out_gga(s(0), s(z0'), true)) -> IF_IN_GGGA(true, s(z0'), s(0)) at position [] and matcher [z0' / z0] IF_IN_GGGA(true, s(z0), s(0)) -> U5_GGGA(s(z0), 0, minus_out_gga(s(z0), 0, s(z0))) with rule IF_IN_GGGA(true, s(z0'), s(0)) -> U5_GGGA(s(z0'), 0, minus_out_gga(s(z0'), 0, s(z0'))) at position [] and matcher [z0' / z0] U5_GGGA(s(z0), 0, minus_out_gga(s(z0), 0, s(z0))) -> DIV_IN_GGA(s(z0), s(0)) with rule U5_GGGA(s(z0'), 0, minus_out_gga(s(z0'), 0, s(z0'))) -> DIV_IN_GGA(s(z0'), s(0)) at position [] and matcher [z0' / z0] DIV_IN_GGA(s(z0), s(0)) -> U3_GGA(s(z0), 0, le_out_gga(s(0), s(z0), true)) with rule DIV_IN_GGA(s(x1), s(0)) -> U3_GGA(s(x1), 0, le_out_gga(s(0), s(x1), true)) 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. ---------------------------------------- (69) NO ---------------------------------------- (70) PrologToPiTRSProof (SOUND) We use the technique of [TOCL09]. With regard to the inferred argument filtering the predicates were used in the following modes: div_in_3: (b,b,f) le_in_3: (b,b,f) if_in_4: (b,b,b,f) minus_in_3: (b,b,f) Transforming Prolog into the following Term Rewriting System: Pi-finite rewrite system: The TRS R consists of the following rules: div_in_gga(X, s(Y), Z) -> U3_gga(X, Y, Z, le_in_gga(s(Y), X, B)) le_in_gga(0, Y, true) -> le_out_gga(0, Y, true) le_in_gga(s(X), 0, false) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y), B) -> U1_gga(X, Y, B, le_in_gga(X, Y, B)) U1_gga(X, Y, B, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) U3_gga(X, Y, Z, le_out_gga(s(Y), X, B)) -> U4_gga(X, Y, Z, if_in_ggga(B, X, s(Y), Z)) if_in_ggga(false, X, s(Y), 0) -> if_out_ggga(false, X, s(Y), 0) if_in_ggga(true, X, s(Y), s(Z)) -> U5_ggga(X, Y, Z, minus_in_gga(X, Y, U)) minus_in_gga(X, 0, X) -> minus_out_gga(X, 0, X) minus_in_gga(s(X), s(Y), Z) -> U2_gga(X, Y, Z, minus_in_gga(X, Y, Z)) U2_gga(X, Y, Z, minus_out_gga(X, Y, Z)) -> minus_out_gga(s(X), s(Y), Z) U5_ggga(X, Y, Z, minus_out_gga(X, Y, U)) -> U6_ggga(X, Y, Z, div_in_gga(U, s(Y), Z)) U6_ggga(X, Y, Z, div_out_gga(U, s(Y), Z)) -> if_out_ggga(true, X, s(Y), s(Z)) U4_gga(X, Y, Z, if_out_ggga(B, X, s(Y), Z)) -> div_out_gga(X, s(Y), Z) The argument filtering Pi contains the following mapping: div_in_gga(x1, x2, x3) = div_in_gga(x1, x2) s(x1) = s(x1) U3_gga(x1, x2, x3, x4) = U3_gga(x1, x2, x4) le_in_gga(x1, x2, x3) = le_in_gga(x1, x2) 0 = 0 le_out_gga(x1, x2, x3) = le_out_gga(x3) U1_gga(x1, x2, x3, x4) = U1_gga(x4) U4_gga(x1, x2, x3, x4) = U4_gga(x4) if_in_ggga(x1, x2, x3, x4) = if_in_ggga(x1, x2, x3) false = false if_out_ggga(x1, x2, x3, x4) = if_out_ggga(x4) true = true U5_ggga(x1, x2, x3, x4) = U5_ggga(x2, x4) minus_in_gga(x1, x2, x3) = minus_in_gga(x1, x2) minus_out_gga(x1, x2, x3) = minus_out_gga(x3) U2_gga(x1, x2, x3, x4) = U2_gga(x4) U6_ggga(x1, x2, x3, x4) = U6_ggga(x4) div_out_gga(x1, x2, x3) = div_out_gga(x3) Infinitary Constructor Rewriting Termination of PiTRS implies Termination of Prolog ---------------------------------------- (71) Obligation: Pi-finite rewrite system: The TRS R consists of the following rules: div_in_gga(X, s(Y), Z) -> U3_gga(X, Y, Z, le_in_gga(s(Y), X, B)) le_in_gga(0, Y, true) -> le_out_gga(0, Y, true) le_in_gga(s(X), 0, false) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y), B) -> U1_gga(X, Y, B, le_in_gga(X, Y, B)) U1_gga(X, Y, B, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) U3_gga(X, Y, Z, le_out_gga(s(Y), X, B)) -> U4_gga(X, Y, Z, if_in_ggga(B, X, s(Y), Z)) if_in_ggga(false, X, s(Y), 0) -> if_out_ggga(false, X, s(Y), 0) if_in_ggga(true, X, s(Y), s(Z)) -> U5_ggga(X, Y, Z, minus_in_gga(X, Y, U)) minus_in_gga(X, 0, X) -> minus_out_gga(X, 0, X) minus_in_gga(s(X), s(Y), Z) -> U2_gga(X, Y, Z, minus_in_gga(X, Y, Z)) U2_gga(X, Y, Z, minus_out_gga(X, Y, Z)) -> minus_out_gga(s(X), s(Y), Z) U5_ggga(X, Y, Z, minus_out_gga(X, Y, U)) -> U6_ggga(X, Y, Z, div_in_gga(U, s(Y), Z)) U6_ggga(X, Y, Z, div_out_gga(U, s(Y), Z)) -> if_out_ggga(true, X, s(Y), s(Z)) U4_gga(X, Y, Z, if_out_ggga(B, X, s(Y), Z)) -> div_out_gga(X, s(Y), Z) The argument filtering Pi contains the following mapping: div_in_gga(x1, x2, x3) = div_in_gga(x1, x2) s(x1) = s(x1) U3_gga(x1, x2, x3, x4) = U3_gga(x1, x2, x4) le_in_gga(x1, x2, x3) = le_in_gga(x1, x2) 0 = 0 le_out_gga(x1, x2, x3) = le_out_gga(x3) U1_gga(x1, x2, x3, x4) = U1_gga(x4) U4_gga(x1, x2, x3, x4) = U4_gga(x4) if_in_ggga(x1, x2, x3, x4) = if_in_ggga(x1, x2, x3) false = false if_out_ggga(x1, x2, x3, x4) = if_out_ggga(x4) true = true U5_ggga(x1, x2, x3, x4) = U5_ggga(x2, x4) minus_in_gga(x1, x2, x3) = minus_in_gga(x1, x2) minus_out_gga(x1, x2, x3) = minus_out_gga(x3) U2_gga(x1, x2, x3, x4) = U2_gga(x4) U6_ggga(x1, x2, x3, x4) = U6_ggga(x4) div_out_gga(x1, x2, x3) = div_out_gga(x3) ---------------------------------------- (72) DependencyPairsProof (EQUIVALENT) Using Dependency Pairs [AG00,LOPSTR] we result in the following initial DP problem: Pi DP problem: The TRS P consists of the following rules: DIV_IN_GGA(X, s(Y), Z) -> U3_GGA(X, Y, Z, le_in_gga(s(Y), X, B)) DIV_IN_GGA(X, s(Y), Z) -> LE_IN_GGA(s(Y), X, B) LE_IN_GGA(s(X), s(Y), B) -> U1_GGA(X, Y, B, le_in_gga(X, Y, B)) LE_IN_GGA(s(X), s(Y), B) -> LE_IN_GGA(X, Y, B) U3_GGA(X, Y, Z, le_out_gga(s(Y), X, B)) -> U4_GGA(X, Y, Z, if_in_ggga(B, X, s(Y), Z)) U3_GGA(X, Y, Z, le_out_gga(s(Y), X, B)) -> IF_IN_GGGA(B, X, s(Y), Z) IF_IN_GGGA(true, X, s(Y), s(Z)) -> U5_GGGA(X, Y, Z, minus_in_gga(X, Y, U)) IF_IN_GGGA(true, X, s(Y), s(Z)) -> MINUS_IN_GGA(X, Y, U) MINUS_IN_GGA(s(X), s(Y), Z) -> U2_GGA(X, Y, Z, minus_in_gga(X, Y, Z)) MINUS_IN_GGA(s(X), s(Y), Z) -> MINUS_IN_GGA(X, Y, Z) U5_GGGA(X, Y, Z, minus_out_gga(X, Y, U)) -> U6_GGGA(X, Y, Z, div_in_gga(U, s(Y), Z)) U5_GGGA(X, Y, Z, minus_out_gga(X, Y, U)) -> DIV_IN_GGA(U, s(Y), Z) The TRS R consists of the following rules: div_in_gga(X, s(Y), Z) -> U3_gga(X, Y, Z, le_in_gga(s(Y), X, B)) le_in_gga(0, Y, true) -> le_out_gga(0, Y, true) le_in_gga(s(X), 0, false) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y), B) -> U1_gga(X, Y, B, le_in_gga(X, Y, B)) U1_gga(X, Y, B, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) U3_gga(X, Y, Z, le_out_gga(s(Y), X, B)) -> U4_gga(X, Y, Z, if_in_ggga(B, X, s(Y), Z)) if_in_ggga(false, X, s(Y), 0) -> if_out_ggga(false, X, s(Y), 0) if_in_ggga(true, X, s(Y), s(Z)) -> U5_ggga(X, Y, Z, minus_in_gga(X, Y, U)) minus_in_gga(X, 0, X) -> minus_out_gga(X, 0, X) minus_in_gga(s(X), s(Y), Z) -> U2_gga(X, Y, Z, minus_in_gga(X, Y, Z)) U2_gga(X, Y, Z, minus_out_gga(X, Y, Z)) -> minus_out_gga(s(X), s(Y), Z) U5_ggga(X, Y, Z, minus_out_gga(X, Y, U)) -> U6_ggga(X, Y, Z, div_in_gga(U, s(Y), Z)) U6_ggga(X, Y, Z, div_out_gga(U, s(Y), Z)) -> if_out_ggga(true, X, s(Y), s(Z)) U4_gga(X, Y, Z, if_out_ggga(B, X, s(Y), Z)) -> div_out_gga(X, s(Y), Z) The argument filtering Pi contains the following mapping: div_in_gga(x1, x2, x3) = div_in_gga(x1, x2) s(x1) = s(x1) U3_gga(x1, x2, x3, x4) = U3_gga(x1, x2, x4) le_in_gga(x1, x2, x3) = le_in_gga(x1, x2) 0 = 0 le_out_gga(x1, x2, x3) = le_out_gga(x3) U1_gga(x1, x2, x3, x4) = U1_gga(x4) U4_gga(x1, x2, x3, x4) = U4_gga(x4) if_in_ggga(x1, x2, x3, x4) = if_in_ggga(x1, x2, x3) false = false if_out_ggga(x1, x2, x3, x4) = if_out_ggga(x4) true = true U5_ggga(x1, x2, x3, x4) = U5_ggga(x2, x4) minus_in_gga(x1, x2, x3) = minus_in_gga(x1, x2) minus_out_gga(x1, x2, x3) = minus_out_gga(x3) U2_gga(x1, x2, x3, x4) = U2_gga(x4) U6_ggga(x1, x2, x3, x4) = U6_ggga(x4) div_out_gga(x1, x2, x3) = div_out_gga(x3) DIV_IN_GGA(x1, x2, x3) = DIV_IN_GGA(x1, x2) U3_GGA(x1, x2, x3, x4) = U3_GGA(x1, x2, x4) LE_IN_GGA(x1, x2, x3) = LE_IN_GGA(x1, x2) U1_GGA(x1, x2, x3, x4) = U1_GGA(x4) U4_GGA(x1, x2, x3, x4) = U4_GGA(x4) IF_IN_GGGA(x1, x2, x3, x4) = IF_IN_GGGA(x1, x2, x3) U5_GGGA(x1, x2, x3, x4) = U5_GGGA(x2, x4) MINUS_IN_GGA(x1, x2, x3) = MINUS_IN_GGA(x1, x2) U2_GGA(x1, x2, x3, x4) = U2_GGA(x4) U6_GGGA(x1, x2, x3, x4) = U6_GGGA(x4) We have to consider all (P,R,Pi)-chains ---------------------------------------- (73) Obligation: Pi DP problem: The TRS P consists of the following rules: DIV_IN_GGA(X, s(Y), Z) -> U3_GGA(X, Y, Z, le_in_gga(s(Y), X, B)) DIV_IN_GGA(X, s(Y), Z) -> LE_IN_GGA(s(Y), X, B) LE_IN_GGA(s(X), s(Y), B) -> U1_GGA(X, Y, B, le_in_gga(X, Y, B)) LE_IN_GGA(s(X), s(Y), B) -> LE_IN_GGA(X, Y, B) U3_GGA(X, Y, Z, le_out_gga(s(Y), X, B)) -> U4_GGA(X, Y, Z, if_in_ggga(B, X, s(Y), Z)) U3_GGA(X, Y, Z, le_out_gga(s(Y), X, B)) -> IF_IN_GGGA(B, X, s(Y), Z) IF_IN_GGGA(true, X, s(Y), s(Z)) -> U5_GGGA(X, Y, Z, minus_in_gga(X, Y, U)) IF_IN_GGGA(true, X, s(Y), s(Z)) -> MINUS_IN_GGA(X, Y, U) MINUS_IN_GGA(s(X), s(Y), Z) -> U2_GGA(X, Y, Z, minus_in_gga(X, Y, Z)) MINUS_IN_GGA(s(X), s(Y), Z) -> MINUS_IN_GGA(X, Y, Z) U5_GGGA(X, Y, Z, minus_out_gga(X, Y, U)) -> U6_GGGA(X, Y, Z, div_in_gga(U, s(Y), Z)) U5_GGGA(X, Y, Z, minus_out_gga(X, Y, U)) -> DIV_IN_GGA(U, s(Y), Z) The TRS R consists of the following rules: div_in_gga(X, s(Y), Z) -> U3_gga(X, Y, Z, le_in_gga(s(Y), X, B)) le_in_gga(0, Y, true) -> le_out_gga(0, Y, true) le_in_gga(s(X), 0, false) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y), B) -> U1_gga(X, Y, B, le_in_gga(X, Y, B)) U1_gga(X, Y, B, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) U3_gga(X, Y, Z, le_out_gga(s(Y), X, B)) -> U4_gga(X, Y, Z, if_in_ggga(B, X, s(Y), Z)) if_in_ggga(false, X, s(Y), 0) -> if_out_ggga(false, X, s(Y), 0) if_in_ggga(true, X, s(Y), s(Z)) -> U5_ggga(X, Y, Z, minus_in_gga(X, Y, U)) minus_in_gga(X, 0, X) -> minus_out_gga(X, 0, X) minus_in_gga(s(X), s(Y), Z) -> U2_gga(X, Y, Z, minus_in_gga(X, Y, Z)) U2_gga(X, Y, Z, minus_out_gga(X, Y, Z)) -> minus_out_gga(s(X), s(Y), Z) U5_ggga(X, Y, Z, minus_out_gga(X, Y, U)) -> U6_ggga(X, Y, Z, div_in_gga(U, s(Y), Z)) U6_ggga(X, Y, Z, div_out_gga(U, s(Y), Z)) -> if_out_ggga(true, X, s(Y), s(Z)) U4_gga(X, Y, Z, if_out_ggga(B, X, s(Y), Z)) -> div_out_gga(X, s(Y), Z) The argument filtering Pi contains the following mapping: div_in_gga(x1, x2, x3) = div_in_gga(x1, x2) s(x1) = s(x1) U3_gga(x1, x2, x3, x4) = U3_gga(x1, x2, x4) le_in_gga(x1, x2, x3) = le_in_gga(x1, x2) 0 = 0 le_out_gga(x1, x2, x3) = le_out_gga(x3) U1_gga(x1, x2, x3, x4) = U1_gga(x4) U4_gga(x1, x2, x3, x4) = U4_gga(x4) if_in_ggga(x1, x2, x3, x4) = if_in_ggga(x1, x2, x3) false = false if_out_ggga(x1, x2, x3, x4) = if_out_ggga(x4) true = true U5_ggga(x1, x2, x3, x4) = U5_ggga(x2, x4) minus_in_gga(x1, x2, x3) = minus_in_gga(x1, x2) minus_out_gga(x1, x2, x3) = minus_out_gga(x3) U2_gga(x1, x2, x3, x4) = U2_gga(x4) U6_ggga(x1, x2, x3, x4) = U6_ggga(x4) div_out_gga(x1, x2, x3) = div_out_gga(x3) DIV_IN_GGA(x1, x2, x3) = DIV_IN_GGA(x1, x2) U3_GGA(x1, x2, x3, x4) = U3_GGA(x1, x2, x4) LE_IN_GGA(x1, x2, x3) = LE_IN_GGA(x1, x2) U1_GGA(x1, x2, x3, x4) = U1_GGA(x4) U4_GGA(x1, x2, x3, x4) = U4_GGA(x4) IF_IN_GGGA(x1, x2, x3, x4) = IF_IN_GGGA(x1, x2, x3) U5_GGGA(x1, x2, x3, x4) = U5_GGGA(x2, x4) MINUS_IN_GGA(x1, x2, x3) = MINUS_IN_GGA(x1, x2) U2_GGA(x1, x2, x3, x4) = U2_GGA(x4) U6_GGGA(x1, x2, x3, x4) = U6_GGGA(x4) We have to consider all (P,R,Pi)-chains ---------------------------------------- (74) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LOPSTR] contains 3 SCCs with 6 less nodes. ---------------------------------------- (75) Complex Obligation (AND) ---------------------------------------- (76) Obligation: Pi DP problem: The TRS P consists of the following rules: MINUS_IN_GGA(s(X), s(Y), Z) -> MINUS_IN_GGA(X, Y, Z) The TRS R consists of the following rules: div_in_gga(X, s(Y), Z) -> U3_gga(X, Y, Z, le_in_gga(s(Y), X, B)) le_in_gga(0, Y, true) -> le_out_gga(0, Y, true) le_in_gga(s(X), 0, false) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y), B) -> U1_gga(X, Y, B, le_in_gga(X, Y, B)) U1_gga(X, Y, B, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) U3_gga(X, Y, Z, le_out_gga(s(Y), X, B)) -> U4_gga(X, Y, Z, if_in_ggga(B, X, s(Y), Z)) if_in_ggga(false, X, s(Y), 0) -> if_out_ggga(false, X, s(Y), 0) if_in_ggga(true, X, s(Y), s(Z)) -> U5_ggga(X, Y, Z, minus_in_gga(X, Y, U)) minus_in_gga(X, 0, X) -> minus_out_gga(X, 0, X) minus_in_gga(s(X), s(Y), Z) -> U2_gga(X, Y, Z, minus_in_gga(X, Y, Z)) U2_gga(X, Y, Z, minus_out_gga(X, Y, Z)) -> minus_out_gga(s(X), s(Y), Z) U5_ggga(X, Y, Z, minus_out_gga(X, Y, U)) -> U6_ggga(X, Y, Z, div_in_gga(U, s(Y), Z)) U6_ggga(X, Y, Z, div_out_gga(U, s(Y), Z)) -> if_out_ggga(true, X, s(Y), s(Z)) U4_gga(X, Y, Z, if_out_ggga(B, X, s(Y), Z)) -> div_out_gga(X, s(Y), Z) The argument filtering Pi contains the following mapping: div_in_gga(x1, x2, x3) = div_in_gga(x1, x2) s(x1) = s(x1) U3_gga(x1, x2, x3, x4) = U3_gga(x1, x2, x4) le_in_gga(x1, x2, x3) = le_in_gga(x1, x2) 0 = 0 le_out_gga(x1, x2, x3) = le_out_gga(x3) U1_gga(x1, x2, x3, x4) = U1_gga(x4) U4_gga(x1, x2, x3, x4) = U4_gga(x4) if_in_ggga(x1, x2, x3, x4) = if_in_ggga(x1, x2, x3) false = false if_out_ggga(x1, x2, x3, x4) = if_out_ggga(x4) true = true U5_ggga(x1, x2, x3, x4) = U5_ggga(x2, x4) minus_in_gga(x1, x2, x3) = minus_in_gga(x1, x2) minus_out_gga(x1, x2, x3) = minus_out_gga(x3) U2_gga(x1, x2, x3, x4) = U2_gga(x4) U6_ggga(x1, x2, x3, x4) = U6_ggga(x4) div_out_gga(x1, x2, x3) = div_out_gga(x3) MINUS_IN_GGA(x1, x2, x3) = MINUS_IN_GGA(x1, x2) We have to consider all (P,R,Pi)-chains ---------------------------------------- (77) UsableRulesProof (EQUIVALENT) For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R. ---------------------------------------- (78) Obligation: Pi DP problem: The TRS P consists of the following rules: MINUS_IN_GGA(s(X), s(Y), Z) -> MINUS_IN_GGA(X, Y, Z) R is empty. The argument filtering Pi contains the following mapping: s(x1) = s(x1) MINUS_IN_GGA(x1, x2, x3) = MINUS_IN_GGA(x1, x2) We have to consider all (P,R,Pi)-chains ---------------------------------------- (79) PiDPToQDPProof (SOUND) Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi. ---------------------------------------- (80) Obligation: Q DP problem: The TRS P consists of the following rules: MINUS_IN_GGA(s(X), s(Y)) -> MINUS_IN_GGA(X, Y) R is empty. Q is empty. We have to consider all (P,Q,R)-chains. ---------------------------------------- (81) 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: *MINUS_IN_GGA(s(X), s(Y)) -> MINUS_IN_GGA(X, Y) The graph contains the following edges 1 > 1, 2 > 2 ---------------------------------------- (82) YES ---------------------------------------- (83) Obligation: Pi DP problem: The TRS P consists of the following rules: LE_IN_GGA(s(X), s(Y), B) -> LE_IN_GGA(X, Y, B) The TRS R consists of the following rules: div_in_gga(X, s(Y), Z) -> U3_gga(X, Y, Z, le_in_gga(s(Y), X, B)) le_in_gga(0, Y, true) -> le_out_gga(0, Y, true) le_in_gga(s(X), 0, false) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y), B) -> U1_gga(X, Y, B, le_in_gga(X, Y, B)) U1_gga(X, Y, B, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) U3_gga(X, Y, Z, le_out_gga(s(Y), X, B)) -> U4_gga(X, Y, Z, if_in_ggga(B, X, s(Y), Z)) if_in_ggga(false, X, s(Y), 0) -> if_out_ggga(false, X, s(Y), 0) if_in_ggga(true, X, s(Y), s(Z)) -> U5_ggga(X, Y, Z, minus_in_gga(X, Y, U)) minus_in_gga(X, 0, X) -> minus_out_gga(X, 0, X) minus_in_gga(s(X), s(Y), Z) -> U2_gga(X, Y, Z, minus_in_gga(X, Y, Z)) U2_gga(X, Y, Z, minus_out_gga(X, Y, Z)) -> minus_out_gga(s(X), s(Y), Z) U5_ggga(X, Y, Z, minus_out_gga(X, Y, U)) -> U6_ggga(X, Y, Z, div_in_gga(U, s(Y), Z)) U6_ggga(X, Y, Z, div_out_gga(U, s(Y), Z)) -> if_out_ggga(true, X, s(Y), s(Z)) U4_gga(X, Y, Z, if_out_ggga(B, X, s(Y), Z)) -> div_out_gga(X, s(Y), Z) The argument filtering Pi contains the following mapping: div_in_gga(x1, x2, x3) = div_in_gga(x1, x2) s(x1) = s(x1) U3_gga(x1, x2, x3, x4) = U3_gga(x1, x2, x4) le_in_gga(x1, x2, x3) = le_in_gga(x1, x2) 0 = 0 le_out_gga(x1, x2, x3) = le_out_gga(x3) U1_gga(x1, x2, x3, x4) = U1_gga(x4) U4_gga(x1, x2, x3, x4) = U4_gga(x4) if_in_ggga(x1, x2, x3, x4) = if_in_ggga(x1, x2, x3) false = false if_out_ggga(x1, x2, x3, x4) = if_out_ggga(x4) true = true U5_ggga(x1, x2, x3, x4) = U5_ggga(x2, x4) minus_in_gga(x1, x2, x3) = minus_in_gga(x1, x2) minus_out_gga(x1, x2, x3) = minus_out_gga(x3) U2_gga(x1, x2, x3, x4) = U2_gga(x4) U6_ggga(x1, x2, x3, x4) = U6_ggga(x4) div_out_gga(x1, x2, x3) = div_out_gga(x3) LE_IN_GGA(x1, x2, x3) = LE_IN_GGA(x1, x2) We have to consider all (P,R,Pi)-chains ---------------------------------------- (84) UsableRulesProof (EQUIVALENT) For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R. ---------------------------------------- (85) Obligation: Pi DP problem: The TRS P consists of the following rules: LE_IN_GGA(s(X), s(Y), B) -> LE_IN_GGA(X, Y, B) R is empty. The argument filtering Pi contains the following mapping: s(x1) = s(x1) LE_IN_GGA(x1, x2, x3) = LE_IN_GGA(x1, x2) We have to consider all (P,R,Pi)-chains ---------------------------------------- (86) PiDPToQDPProof (SOUND) Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi. ---------------------------------------- (87) Obligation: Q DP problem: The TRS P consists of the following rules: LE_IN_GGA(s(X), s(Y)) -> LE_IN_GGA(X, Y) R is empty. Q is empty. We have to consider all (P,Q,R)-chains. ---------------------------------------- (88) 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: *LE_IN_GGA(s(X), s(Y)) -> LE_IN_GGA(X, Y) The graph contains the following edges 1 > 1, 2 > 2 ---------------------------------------- (89) YES ---------------------------------------- (90) Obligation: Pi DP problem: The TRS P consists of the following rules: U3_GGA(X, Y, Z, le_out_gga(s(Y), X, B)) -> IF_IN_GGGA(B, X, s(Y), Z) IF_IN_GGGA(true, X, s(Y), s(Z)) -> U5_GGGA(X, Y, Z, minus_in_gga(X, Y, U)) U5_GGGA(X, Y, Z, minus_out_gga(X, Y, U)) -> DIV_IN_GGA(U, s(Y), Z) DIV_IN_GGA(X, s(Y), Z) -> U3_GGA(X, Y, Z, le_in_gga(s(Y), X, B)) The TRS R consists of the following rules: div_in_gga(X, s(Y), Z) -> U3_gga(X, Y, Z, le_in_gga(s(Y), X, B)) le_in_gga(0, Y, true) -> le_out_gga(0, Y, true) le_in_gga(s(X), 0, false) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y), B) -> U1_gga(X, Y, B, le_in_gga(X, Y, B)) U1_gga(X, Y, B, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) U3_gga(X, Y, Z, le_out_gga(s(Y), X, B)) -> U4_gga(X, Y, Z, if_in_ggga(B, X, s(Y), Z)) if_in_ggga(false, X, s(Y), 0) -> if_out_ggga(false, X, s(Y), 0) if_in_ggga(true, X, s(Y), s(Z)) -> U5_ggga(X, Y, Z, minus_in_gga(X, Y, U)) minus_in_gga(X, 0, X) -> minus_out_gga(X, 0, X) minus_in_gga(s(X), s(Y), Z) -> U2_gga(X, Y, Z, minus_in_gga(X, Y, Z)) U2_gga(X, Y, Z, minus_out_gga(X, Y, Z)) -> minus_out_gga(s(X), s(Y), Z) U5_ggga(X, Y, Z, minus_out_gga(X, Y, U)) -> U6_ggga(X, Y, Z, div_in_gga(U, s(Y), Z)) U6_ggga(X, Y, Z, div_out_gga(U, s(Y), Z)) -> if_out_ggga(true, X, s(Y), s(Z)) U4_gga(X, Y, Z, if_out_ggga(B, X, s(Y), Z)) -> div_out_gga(X, s(Y), Z) The argument filtering Pi contains the following mapping: div_in_gga(x1, x2, x3) = div_in_gga(x1, x2) s(x1) = s(x1) U3_gga(x1, x2, x3, x4) = U3_gga(x1, x2, x4) le_in_gga(x1, x2, x3) = le_in_gga(x1, x2) 0 = 0 le_out_gga(x1, x2, x3) = le_out_gga(x3) U1_gga(x1, x2, x3, x4) = U1_gga(x4) U4_gga(x1, x2, x3, x4) = U4_gga(x4) if_in_ggga(x1, x2, x3, x4) = if_in_ggga(x1, x2, x3) false = false if_out_ggga(x1, x2, x3, x4) = if_out_ggga(x4) true = true U5_ggga(x1, x2, x3, x4) = U5_ggga(x2, x4) minus_in_gga(x1, x2, x3) = minus_in_gga(x1, x2) minus_out_gga(x1, x2, x3) = minus_out_gga(x3) U2_gga(x1, x2, x3, x4) = U2_gga(x4) U6_ggga(x1, x2, x3, x4) = U6_ggga(x4) div_out_gga(x1, x2, x3) = div_out_gga(x3) DIV_IN_GGA(x1, x2, x3) = DIV_IN_GGA(x1, x2) U3_GGA(x1, x2, x3, x4) = U3_GGA(x1, x2, x4) IF_IN_GGGA(x1, x2, x3, x4) = IF_IN_GGGA(x1, x2, x3) U5_GGGA(x1, x2, x3, x4) = U5_GGGA(x2, x4) We have to consider all (P,R,Pi)-chains ---------------------------------------- (91) UsableRulesProof (EQUIVALENT) For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R. ---------------------------------------- (92) Obligation: Pi DP problem: The TRS P consists of the following rules: U3_GGA(X, Y, Z, le_out_gga(s(Y), X, B)) -> IF_IN_GGGA(B, X, s(Y), Z) IF_IN_GGGA(true, X, s(Y), s(Z)) -> U5_GGGA(X, Y, Z, minus_in_gga(X, Y, U)) U5_GGGA(X, Y, Z, minus_out_gga(X, Y, U)) -> DIV_IN_GGA(U, s(Y), Z) DIV_IN_GGA(X, s(Y), Z) -> U3_GGA(X, Y, Z, le_in_gga(s(Y), X, B)) The TRS R consists of the following rules: minus_in_gga(X, 0, X) -> minus_out_gga(X, 0, X) minus_in_gga(s(X), s(Y), Z) -> U2_gga(X, Y, Z, minus_in_gga(X, Y, Z)) le_in_gga(s(X), 0, false) -> le_out_gga(s(X), 0, false) le_in_gga(s(X), s(Y), B) -> U1_gga(X, Y, B, le_in_gga(X, Y, B)) U2_gga(X, Y, Z, minus_out_gga(X, Y, Z)) -> minus_out_gga(s(X), s(Y), Z) U1_gga(X, Y, B, le_out_gga(X, Y, B)) -> le_out_gga(s(X), s(Y), B) le_in_gga(0, Y, true) -> le_out_gga(0, Y, true) The argument filtering Pi contains the following mapping: s(x1) = s(x1) le_in_gga(x1, x2, x3) = le_in_gga(x1, x2) 0 = 0 le_out_gga(x1, x2, x3) = le_out_gga(x3) U1_gga(x1, x2, x3, x4) = U1_gga(x4) false = false true = true minus_in_gga(x1, x2, x3) = minus_in_gga(x1, x2) minus_out_gga(x1, x2, x3) = minus_out_gga(x3) U2_gga(x1, x2, x3, x4) = U2_gga(x4) DIV_IN_GGA(x1, x2, x3) = DIV_IN_GGA(x1, x2) U3_GGA(x1, x2, x3, x4) = U3_GGA(x1, x2, x4) IF_IN_GGGA(x1, x2, x3, x4) = IF_IN_GGGA(x1, x2, x3) U5_GGGA(x1, x2, x3, x4) = U5_GGGA(x2, x4) We have to consider all (P,R,Pi)-chains ---------------------------------------- (93) PiDPToQDPProof (SOUND) Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi. ---------------------------------------- (94) Obligation: Q DP problem: The TRS P consists of the following rules: U3_GGA(X, Y, le_out_gga(B)) -> IF_IN_GGGA(B, X, s(Y)) IF_IN_GGGA(true, X, s(Y)) -> U5_GGGA(Y, minus_in_gga(X, Y)) U5_GGGA(Y, minus_out_gga(U)) -> DIV_IN_GGA(U, s(Y)) DIV_IN_GGA(X, s(Y)) -> U3_GGA(X, Y, le_in_gga(s(Y), X)) The TRS R consists of the following rules: minus_in_gga(X, 0) -> minus_out_gga(X) minus_in_gga(s(X), s(Y)) -> U2_gga(minus_in_gga(X, Y)) le_in_gga(s(X), 0) -> le_out_gga(false) le_in_gga(s(X), s(Y)) -> U1_gga(le_in_gga(X, Y)) U2_gga(minus_out_gga(Z)) -> minus_out_gga(Z) U1_gga(le_out_gga(B)) -> le_out_gga(B) le_in_gga(0, Y) -> le_out_gga(true) The set Q consists of the following terms: minus_in_gga(x0, x1) le_in_gga(x0, x1) U2_gga(x0) U1_gga(x0) We have to consider all (P,Q,R)-chains. ---------------------------------------- (95) TransformationProof (SOUND) By narrowing [LPAR04] the rule IF_IN_GGGA(true, X, s(Y)) -> U5_GGGA(Y, minus_in_gga(X, Y)) at position [1] we obtained the following new rules [LPAR04]: (IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(0, minus_out_gga(x0)),IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(0, minus_out_gga(x0))) (IF_IN_GGGA(true, s(x0), s(s(x1))) -> U5_GGGA(s(x1), U2_gga(minus_in_gga(x0, x1))),IF_IN_GGGA(true, s(x0), s(s(x1))) -> U5_GGGA(s(x1), U2_gga(minus_in_gga(x0, x1)))) ---------------------------------------- (96) Obligation: Q DP problem: The TRS P consists of the following rules: U3_GGA(X, Y, le_out_gga(B)) -> IF_IN_GGGA(B, X, s(Y)) U5_GGGA(Y, minus_out_gga(U)) -> DIV_IN_GGA(U, s(Y)) DIV_IN_GGA(X, s(Y)) -> U3_GGA(X, Y, le_in_gga(s(Y), X)) IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(0, minus_out_gga(x0)) IF_IN_GGGA(true, s(x0), s(s(x1))) -> U5_GGGA(s(x1), U2_gga(minus_in_gga(x0, x1))) The TRS R consists of the following rules: minus_in_gga(X, 0) -> minus_out_gga(X) minus_in_gga(s(X), s(Y)) -> U2_gga(minus_in_gga(X, Y)) le_in_gga(s(X), 0) -> le_out_gga(false) le_in_gga(s(X), s(Y)) -> U1_gga(le_in_gga(X, Y)) U2_gga(minus_out_gga(Z)) -> minus_out_gga(Z) U1_gga(le_out_gga(B)) -> le_out_gga(B) le_in_gga(0, Y) -> le_out_gga(true) The set Q consists of the following terms: minus_in_gga(x0, x1) le_in_gga(x0, x1) U2_gga(x0) U1_gga(x0) We have to consider all (P,Q,R)-chains. ---------------------------------------- (97) TransformationProof (SOUND) By narrowing [LPAR04] the rule DIV_IN_GGA(X, s(Y)) -> U3_GGA(X, Y, le_in_gga(s(Y), X)) at position [2] we obtained the following new rules [LPAR04]: (DIV_IN_GGA(0, s(x0)) -> U3_GGA(0, x0, le_out_gga(false)),DIV_IN_GGA(0, s(x0)) -> U3_GGA(0, x0, le_out_gga(false))) (DIV_IN_GGA(s(x1), s(x0)) -> U3_GGA(s(x1), x0, U1_gga(le_in_gga(x0, x1))),DIV_IN_GGA(s(x1), s(x0)) -> U3_GGA(s(x1), x0, U1_gga(le_in_gga(x0, x1)))) ---------------------------------------- (98) Obligation: Q DP problem: The TRS P consists of the following rules: U3_GGA(X, Y, le_out_gga(B)) -> IF_IN_GGGA(B, X, s(Y)) U5_GGGA(Y, minus_out_gga(U)) -> DIV_IN_GGA(U, s(Y)) IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(0, minus_out_gga(x0)) IF_IN_GGGA(true, s(x0), s(s(x1))) -> U5_GGGA(s(x1), U2_gga(minus_in_gga(x0, x1))) DIV_IN_GGA(0, s(x0)) -> U3_GGA(0, x0, le_out_gga(false)) DIV_IN_GGA(s(x1), s(x0)) -> U3_GGA(s(x1), x0, U1_gga(le_in_gga(x0, x1))) The TRS R consists of the following rules: minus_in_gga(X, 0) -> minus_out_gga(X) minus_in_gga(s(X), s(Y)) -> U2_gga(minus_in_gga(X, Y)) le_in_gga(s(X), 0) -> le_out_gga(false) le_in_gga(s(X), s(Y)) -> U1_gga(le_in_gga(X, Y)) U2_gga(minus_out_gga(Z)) -> minus_out_gga(Z) U1_gga(le_out_gga(B)) -> le_out_gga(B) le_in_gga(0, Y) -> le_out_gga(true) The set Q consists of the following terms: minus_in_gga(x0, x1) le_in_gga(x0, x1) U2_gga(x0) U1_gga(x0) We have to consider all (P,Q,R)-chains. ---------------------------------------- (99) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule U3_GGA(X, Y, le_out_gga(B)) -> IF_IN_GGGA(B, X, s(Y)) we obtained the following new rules [LPAR04]: (U3_GGA(0, z0, le_out_gga(false)) -> IF_IN_GGGA(false, 0, s(z0)),U3_GGA(0, z0, le_out_gga(false)) -> IF_IN_GGGA(false, 0, s(z0))) (U3_GGA(s(z0), z1, le_out_gga(x2)) -> IF_IN_GGGA(x2, s(z0), s(z1)),U3_GGA(s(z0), z1, le_out_gga(x2)) -> IF_IN_GGGA(x2, s(z0), s(z1))) ---------------------------------------- (100) Obligation: Q DP problem: The TRS P consists of the following rules: U5_GGGA(Y, minus_out_gga(U)) -> DIV_IN_GGA(U, s(Y)) IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(0, minus_out_gga(x0)) IF_IN_GGGA(true, s(x0), s(s(x1))) -> U5_GGGA(s(x1), U2_gga(minus_in_gga(x0, x1))) DIV_IN_GGA(0, s(x0)) -> U3_GGA(0, x0, le_out_gga(false)) DIV_IN_GGA(s(x1), s(x0)) -> U3_GGA(s(x1), x0, U1_gga(le_in_gga(x0, x1))) U3_GGA(0, z0, le_out_gga(false)) -> IF_IN_GGGA(false, 0, s(z0)) U3_GGA(s(z0), z1, le_out_gga(x2)) -> IF_IN_GGGA(x2, s(z0), s(z1)) The TRS R consists of the following rules: minus_in_gga(X, 0) -> minus_out_gga(X) minus_in_gga(s(X), s(Y)) -> U2_gga(minus_in_gga(X, Y)) le_in_gga(s(X), 0) -> le_out_gga(false) le_in_gga(s(X), s(Y)) -> U1_gga(le_in_gga(X, Y)) U2_gga(minus_out_gga(Z)) -> minus_out_gga(Z) U1_gga(le_out_gga(B)) -> le_out_gga(B) le_in_gga(0, Y) -> le_out_gga(true) The set Q consists of the following terms: minus_in_gga(x0, x1) le_in_gga(x0, x1) U2_gga(x0) U1_gga(x0) We have to consider all (P,Q,R)-chains. ---------------------------------------- (101) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes. ---------------------------------------- (102) Obligation: Q DP problem: The TRS P consists of the following rules: DIV_IN_GGA(s(x1), s(x0)) -> U3_GGA(s(x1), x0, U1_gga(le_in_gga(x0, x1))) U3_GGA(s(z0), z1, le_out_gga(x2)) -> IF_IN_GGGA(x2, s(z0), s(z1)) IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(0, minus_out_gga(x0)) U5_GGGA(Y, minus_out_gga(U)) -> DIV_IN_GGA(U, s(Y)) IF_IN_GGGA(true, s(x0), s(s(x1))) -> U5_GGGA(s(x1), U2_gga(minus_in_gga(x0, x1))) The TRS R consists of the following rules: minus_in_gga(X, 0) -> minus_out_gga(X) minus_in_gga(s(X), s(Y)) -> U2_gga(minus_in_gga(X, Y)) le_in_gga(s(X), 0) -> le_out_gga(false) le_in_gga(s(X), s(Y)) -> U1_gga(le_in_gga(X, Y)) U2_gga(minus_out_gga(Z)) -> minus_out_gga(Z) U1_gga(le_out_gga(B)) -> le_out_gga(B) le_in_gga(0, Y) -> le_out_gga(true) The set Q consists of the following terms: minus_in_gga(x0, x1) le_in_gga(x0, x1) U2_gga(x0) U1_gga(x0) We have to consider all (P,Q,R)-chains. ---------------------------------------- (103) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule IF_IN_GGGA(true, x0, s(0)) -> U5_GGGA(0, minus_out_gga(x0)) we obtained the following new rules [LPAR04]: (IF_IN_GGGA(true, s(z0), s(0)) -> U5_GGGA(0, minus_out_gga(s(z0))),IF_IN_GGGA(true, s(z0), s(0)) -> U5_GGGA(0, minus_out_gga(s(z0)))) ---------------------------------------- (104) Obligation: Q DP problem: The TRS P consists of the following rules: DIV_IN_GGA(s(x1), s(x0)) -> U3_GGA(s(x1), x0, U1_gga(le_in_gga(x0, x1))) U3_GGA(s(z0), z1, le_out_gga(x2)) -> IF_IN_GGGA(x2, s(z0), s(z1)) U5_GGGA(Y, minus_out_gga(U)) -> DIV_IN_GGA(U, s(Y)) IF_IN_GGGA(true, s(x0), s(s(x1))) -> U5_GGGA(s(x1), U2_gga(minus_in_gga(x0, x1))) IF_IN_GGGA(true, s(z0), s(0)) -> U5_GGGA(0, minus_out_gga(s(z0))) The TRS R consists of the following rules: minus_in_gga(X, 0) -> minus_out_gga(X) minus_in_gga(s(X), s(Y)) -> U2_gga(minus_in_gga(X, Y)) le_in_gga(s(X), 0) -> le_out_gga(false) le_in_gga(s(X), s(Y)) -> U1_gga(le_in_gga(X, Y)) U2_gga(minus_out_gga(Z)) -> minus_out_gga(Z) U1_gga(le_out_gga(B)) -> le_out_gga(B) le_in_gga(0, Y) -> le_out_gga(true) The set Q consists of the following terms: minus_in_gga(x0, x1) le_in_gga(x0, x1) U2_gga(x0) U1_gga(x0) We have to consider all (P,Q,R)-chains. ---------------------------------------- (105) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule U5_GGGA(Y, minus_out_gga(U)) -> DIV_IN_GGA(U, s(Y)) we obtained the following new rules [LPAR04]: (U5_GGGA(s(z1), minus_out_gga(x1)) -> DIV_IN_GGA(x1, s(s(z1))),U5_GGGA(s(z1), minus_out_gga(x1)) -> DIV_IN_GGA(x1, s(s(z1)))) (U5_GGGA(0, minus_out_gga(s(z0))) -> DIV_IN_GGA(s(z0), s(0)),U5_GGGA(0, minus_out_gga(s(z0))) -> DIV_IN_GGA(s(z0), s(0))) ---------------------------------------- (106) Obligation: Q DP problem: The TRS P consists of the following rules: DIV_IN_GGA(s(x1), s(x0)) -> U3_GGA(s(x1), x0, U1_gga(le_in_gga(x0, x1))) U3_GGA(s(z0), z1, le_out_gga(x2)) -> IF_IN_GGGA(x2, s(z0), s(z1)) IF_IN_GGGA(true, s(x0), s(s(x1))) -> U5_GGGA(s(x1), U2_gga(minus_in_gga(x0, x1))) IF_IN_GGGA(true, s(z0), s(0)) -> U5_GGGA(0, minus_out_gga(s(z0))) U5_GGGA(s(z1), minus_out_gga(x1)) -> DIV_IN_GGA(x1, s(s(z1))) U5_GGGA(0, minus_out_gga(s(z0))) -> DIV_IN_GGA(s(z0), s(0)) The TRS R consists of the following rules: minus_in_gga(X, 0) -> minus_out_gga(X) minus_in_gga(s(X), s(Y)) -> U2_gga(minus_in_gga(X, Y)) le_in_gga(s(X), 0) -> le_out_gga(false) le_in_gga(s(X), s(Y)) -> U1_gga(le_in_gga(X, Y)) U2_gga(minus_out_gga(Z)) -> minus_out_gga(Z) U1_gga(le_out_gga(B)) -> le_out_gga(B) le_in_gga(0, Y) -> le_out_gga(true) The set Q consists of the following terms: minus_in_gga(x0, x1) le_in_gga(x0, x1) U2_gga(x0) U1_gga(x0) We have to consider all (P,Q,R)-chains. ---------------------------------------- (107) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule DIV_IN_GGA(s(x1), s(x0)) -> U3_GGA(s(x1), x0, U1_gga(le_in_gga(x0, x1))) we obtained the following new rules [LPAR04]: (DIV_IN_GGA(s(x0), s(s(z0))) -> U3_GGA(s(x0), s(z0), U1_gga(le_in_gga(s(z0), x0))),DIV_IN_GGA(s(x0), s(s(z0))) -> U3_GGA(s(x0), s(z0), U1_gga(le_in_gga(s(z0), x0)))) (DIV_IN_GGA(s(z0), s(0)) -> U3_GGA(s(z0), 0, U1_gga(le_in_gga(0, z0))),DIV_IN_GGA(s(z0), s(0)) -> U3_GGA(s(z0), 0, U1_gga(le_in_gga(0, z0)))) ---------------------------------------- (108) Obligation: Q DP problem: The TRS P consists of the following rules: U3_GGA(s(z0), z1, le_out_gga(x2)) -> IF_IN_GGGA(x2, s(z0), s(z1)) IF_IN_GGGA(true, s(x0), s(s(x1))) -> U5_GGGA(s(x1), U2_gga(minus_in_gga(x0, x1))) IF_IN_GGGA(true, s(z0), s(0)) -> U5_GGGA(0, minus_out_gga(s(z0))) U5_GGGA(s(z1), minus_out_gga(x1)) -> DIV_IN_GGA(x1, s(s(z1))) U5_GGGA(0, minus_out_gga(s(z0))) -> DIV_IN_GGA(s(z0), s(0)) DIV_IN_GGA(s(x0), s(s(z0))) -> U3_GGA(s(x0), s(z0), U1_gga(le_in_gga(s(z0), x0))) DIV_IN_GGA(s(z0), s(0)) -> U3_GGA(s(z0), 0, U1_gga(le_in_gga(0, z0))) The TRS R consists of the following rules: minus_in_gga(X, 0) -> minus_out_gga(X) minus_in_gga(s(X), s(Y)) -> U2_gga(minus_in_gga(X, Y)) le_in_gga(s(X), 0) -> le_out_gga(false) le_in_gga(s(X), s(Y)) -> U1_gga(le_in_gga(X, Y)) U2_gga(minus_out_gga(Z)) -> minus_out_gga(Z) U1_gga(le_out_gga(B)) -> le_out_gga(B) le_in_gga(0, Y) -> le_out_gga(true) The set Q consists of the following terms: minus_in_gga(x0, x1) le_in_gga(x0, x1) U2_gga(x0) U1_gga(x0) We have to consider all (P,Q,R)-chains. ---------------------------------------- (109) TransformationProof (EQUIVALENT) By rewriting [LPAR04] the rule DIV_IN_GGA(s(z0), s(0)) -> U3_GGA(s(z0), 0, U1_gga(le_in_gga(0, z0))) at position [2,0] we obtained the following new rules [LPAR04]: (DIV_IN_GGA(s(z0), s(0)) -> U3_GGA(s(z0), 0, U1_gga(le_out_gga(true))),DIV_IN_GGA(s(z0), s(0)) -> U3_GGA(s(z0), 0, U1_gga(le_out_gga(true)))) ---------------------------------------- (110) Obligation: Q DP problem: The TRS P consists of the following rules: U3_GGA(s(z0), z1, le_out_gga(x2)) -> IF_IN_GGGA(x2, s(z0), s(z1)) IF_IN_GGGA(true, s(x0), s(s(x1))) -> U5_GGGA(s(x1), U2_gga(minus_in_gga(x0, x1))) IF_IN_GGGA(true, s(z0), s(0)) -> U5_GGGA(0, minus_out_gga(s(z0))) U5_GGGA(s(z1), minus_out_gga(x1)) -> DIV_IN_GGA(x1, s(s(z1))) U5_GGGA(0, minus_out_gga(s(z0))) -> DIV_IN_GGA(s(z0), s(0)) DIV_IN_GGA(s(x0), s(s(z0))) -> U3_GGA(s(x0), s(z0), U1_gga(le_in_gga(s(z0), x0))) DIV_IN_GGA(s(z0), s(0)) -> U3_GGA(s(z0), 0, U1_gga(le_out_gga(true))) The TRS R consists of the following rules: minus_in_gga(X, 0) -> minus_out_gga(X) minus_in_gga(s(X), s(Y)) -> U2_gga(minus_in_gga(X, Y)) le_in_gga(s(X), 0) -> le_out_gga(false) le_in_gga(s(X), s(Y)) -> U1_gga(le_in_gga(X, Y)) U2_gga(minus_out_gga(Z)) -> minus_out_gga(Z) U1_gga(le_out_gga(B)) -> le_out_gga(B) le_in_gga(0, Y) -> le_out_gga(true) The set Q consists of the following terms: minus_in_gga(x0, x1) le_in_gga(x0, x1) U2_gga(x0) U1_gga(x0) We have to consider all (P,Q,R)-chains. ---------------------------------------- (111) TransformationProof (EQUIVALENT) By rewriting [LPAR04] the rule DIV_IN_GGA(s(z0), s(0)) -> U3_GGA(s(z0), 0, U1_gga(le_out_gga(true))) at position [2] we obtained the following new rules [LPAR04]: (DIV_IN_GGA(s(z0), s(0)) -> U3_GGA(s(z0), 0, le_out_gga(true)),DIV_IN_GGA(s(z0), s(0)) -> U3_GGA(s(z0), 0, le_out_gga(true))) ---------------------------------------- (112) Obligation: Q DP problem: The TRS P consists of the following rules: U3_GGA(s(z0), z1, le_out_gga(x2)) -> IF_IN_GGGA(x2, s(z0), s(z1)) IF_IN_GGGA(true, s(x0), s(s(x1))) -> U5_GGGA(s(x1), U2_gga(minus_in_gga(x0, x1))) IF_IN_GGGA(true, s(z0), s(0)) -> U5_GGGA(0, minus_out_gga(s(z0))) U5_GGGA(s(z1), minus_out_gga(x1)) -> DIV_IN_GGA(x1, s(s(z1))) U5_GGGA(0, minus_out_gga(s(z0))) -> DIV_IN_GGA(s(z0), s(0)) DIV_IN_GGA(s(x0), s(s(z0))) -> U3_GGA(s(x0), s(z0), U1_gga(le_in_gga(s(z0), x0))) DIV_IN_GGA(s(z0), s(0)) -> U3_GGA(s(z0), 0, le_out_gga(true)) The TRS R consists of the following rules: minus_in_gga(X, 0) -> minus_out_gga(X) minus_in_gga(s(X), s(Y)) -> U2_gga(minus_in_gga(X, Y)) le_in_gga(s(X), 0) -> le_out_gga(false) le_in_gga(s(X), s(Y)) -> U1_gga(le_in_gga(X, Y)) U2_gga(minus_out_gga(Z)) -> minus_out_gga(Z) U1_gga(le_out_gga(B)) -> le_out_gga(B) le_in_gga(0, Y) -> le_out_gga(true) The set Q consists of the following terms: minus_in_gga(x0, x1) le_in_gga(x0, x1) U2_gga(x0) U1_gga(x0) We have to consider all (P,Q,R)-chains. ---------------------------------------- (113) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule U3_GGA(s(z0), z1, le_out_gga(x2)) -> IF_IN_GGGA(x2, s(z0), s(z1)) we obtained the following new rules [LPAR04]: (U3_GGA(s(z0), s(z1), le_out_gga(x2)) -> IF_IN_GGGA(x2, s(z0), s(s(z1))),U3_GGA(s(z0), s(z1), le_out_gga(x2)) -> IF_IN_GGGA(x2, s(z0), s(s(z1)))) (U3_GGA(s(z0), 0, le_out_gga(true)) -> IF_IN_GGGA(true, s(z0), s(0)),U3_GGA(s(z0), 0, le_out_gga(true)) -> IF_IN_GGGA(true, s(z0), s(0))) ---------------------------------------- (114) Obligation: Q DP problem: The TRS P consists of the following rules: IF_IN_GGGA(true, s(x0), s(s(x1))) -> U5_GGGA(s(x1), U2_gga(minus_in_gga(x0, x1))) IF_IN_GGGA(true, s(z0), s(0)) -> U5_GGGA(0, minus_out_gga(s(z0))) U5_GGGA(s(z1), minus_out_gga(x1)) -> DIV_IN_GGA(x1, s(s(z1))) U5_GGGA(0, minus_out_gga(s(z0))) -> DIV_IN_GGA(s(z0), s(0)) DIV_IN_GGA(s(x0), s(s(z0))) -> U3_GGA(s(x0), s(z0), U1_gga(le_in_gga(s(z0), x0))) DIV_IN_GGA(s(z0), s(0)) -> U3_GGA(s(z0), 0, le_out_gga(true)) U3_GGA(s(z0), s(z1), le_out_gga(x2)) -> IF_IN_GGGA(x2, s(z0), s(s(z1))) U3_GGA(s(z0), 0, le_out_gga(true)) -> IF_IN_GGGA(true, s(z0), s(0)) The TRS R consists of the following rules: minus_in_gga(X, 0) -> minus_out_gga(X) minus_in_gga(s(X), s(Y)) -> U2_gga(minus_in_gga(X, Y)) le_in_gga(s(X), 0) -> le_out_gga(false) le_in_gga(s(X), s(Y)) -> U1_gga(le_in_gga(X, Y)) U2_gga(minus_out_gga(Z)) -> minus_out_gga(Z) U1_gga(le_out_gga(B)) -> le_out_gga(B) le_in_gga(0, Y) -> le_out_gga(true) The set Q consists of the following terms: minus_in_gga(x0, x1) le_in_gga(x0, x1) U2_gga(x0) U1_gga(x0) We have to consider all (P,Q,R)-chains. ---------------------------------------- (115) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 2 SCCs. ---------------------------------------- (116) Complex Obligation (AND) ---------------------------------------- (117) Obligation: Q DP problem: The TRS P consists of the following rules: U5_GGGA(0, minus_out_gga(s(z0))) -> DIV_IN_GGA(s(z0), s(0)) DIV_IN_GGA(s(z0), s(0)) -> U3_GGA(s(z0), 0, le_out_gga(true)) U3_GGA(s(z0), 0, le_out_gga(true)) -> IF_IN_GGGA(true, s(z0), s(0)) IF_IN_GGGA(true, s(z0), s(0)) -> U5_GGGA(0, minus_out_gga(s(z0))) The TRS R consists of the following rules: minus_in_gga(X, 0) -> minus_out_gga(X) minus_in_gga(s(X), s(Y)) -> U2_gga(minus_in_gga(X, Y)) le_in_gga(s(X), 0) -> le_out_gga(false) le_in_gga(s(X), s(Y)) -> U1_gga(le_in_gga(X, Y)) U2_gga(minus_out_gga(Z)) -> minus_out_gga(Z) U1_gga(le_out_gga(B)) -> le_out_gga(B) le_in_gga(0, Y) -> le_out_gga(true) The set Q consists of the following terms: minus_in_gga(x0, x1) le_in_gga(x0, x1) U2_gga(x0) U1_gga(x0) We have to consider all (P,Q,R)-chains. ---------------------------------------- (118) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (119) Obligation: Q DP problem: The TRS P consists of the following rules: U5_GGGA(0, minus_out_gga(s(z0))) -> DIV_IN_GGA(s(z0), s(0)) DIV_IN_GGA(s(z0), s(0)) -> U3_GGA(s(z0), 0, le_out_gga(true)) U3_GGA(s(z0), 0, le_out_gga(true)) -> IF_IN_GGGA(true, s(z0), s(0)) IF_IN_GGGA(true, s(z0), s(0)) -> U5_GGGA(0, minus_out_gga(s(z0))) R is empty. The set Q consists of the following terms: minus_in_gga(x0, x1) le_in_gga(x0, x1) U2_gga(x0) U1_gga(x0) We have to consider all (P,Q,R)-chains. ---------------------------------------- (120) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. minus_in_gga(x0, x1) le_in_gga(x0, x1) U2_gga(x0) U1_gga(x0) ---------------------------------------- (121) Obligation: Q DP problem: The TRS P consists of the following rules: U5_GGGA(0, minus_out_gga(s(z0))) -> DIV_IN_GGA(s(z0), s(0)) DIV_IN_GGA(s(z0), s(0)) -> U3_GGA(s(z0), 0, le_out_gga(true)) U3_GGA(s(z0), 0, le_out_gga(true)) -> IF_IN_GGGA(true, s(z0), s(0)) IF_IN_GGGA(true, s(z0), s(0)) -> U5_GGGA(0, minus_out_gga(s(z0))) R is empty. Q is empty. We have to consider all (P,Q,R)-chains. ---------------------------------------- (122) 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 = DIV_IN_GGA(s(z0'), s(0)) evaluates to t =DIV_IN_GGA(s(z0'), s(0)) Thus s starts an infinite chain as s semiunifies with t with the following substitutions: * Matcher: [ ] * Semiunifier: [ ] -------------------------------------------------------------------------------- Rewriting sequence DIV_IN_GGA(s(z0'), s(0)) -> U3_GGA(s(z0'), 0, le_out_gga(true)) with rule DIV_IN_GGA(s(z0''), s(0)) -> U3_GGA(s(z0''), 0, le_out_gga(true)) at position [] and matcher [z0'' / z0'] U3_GGA(s(z0'), 0, le_out_gga(true)) -> IF_IN_GGGA(true, s(z0'), s(0)) with rule U3_GGA(s(z0), 0, le_out_gga(true)) -> IF_IN_GGGA(true, s(z0), s(0)) at position [] and matcher [z0 / z0'] IF_IN_GGGA(true, s(z0'), s(0)) -> U5_GGGA(0, minus_out_gga(s(z0'))) with rule IF_IN_GGGA(true, s(z0''), s(0)) -> U5_GGGA(0, minus_out_gga(s(z0''))) at position [] and matcher [z0'' / z0'] U5_GGGA(0, minus_out_gga(s(z0'))) -> DIV_IN_GGA(s(z0'), s(0)) with rule U5_GGGA(0, minus_out_gga(s(z0))) -> DIV_IN_GGA(s(z0), s(0)) 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. ---------------------------------------- (123) NO ---------------------------------------- (124) Obligation: Q DP problem: The TRS P consists of the following rules: U5_GGGA(s(z1), minus_out_gga(x1)) -> DIV_IN_GGA(x1, s(s(z1))) DIV_IN_GGA(s(x0), s(s(z0))) -> U3_GGA(s(x0), s(z0), U1_gga(le_in_gga(s(z0), x0))) U3_GGA(s(z0), s(z1), le_out_gga(x2)) -> IF_IN_GGGA(x2, s(z0), s(s(z1))) IF_IN_GGGA(true, s(x0), s(s(x1))) -> U5_GGGA(s(x1), U2_gga(minus_in_gga(x0, x1))) The TRS R consists of the following rules: minus_in_gga(X, 0) -> minus_out_gga(X) minus_in_gga(s(X), s(Y)) -> U2_gga(minus_in_gga(X, Y)) le_in_gga(s(X), 0) -> le_out_gga(false) le_in_gga(s(X), s(Y)) -> U1_gga(le_in_gga(X, Y)) U2_gga(minus_out_gga(Z)) -> minus_out_gga(Z) U1_gga(le_out_gga(B)) -> le_out_gga(B) le_in_gga(0, Y) -> le_out_gga(true) The set Q consists of the following terms: minus_in_gga(x0, x1) le_in_gga(x0, x1) U2_gga(x0) U1_gga(x0) We have to consider all (P,Q,R)-chains. ---------------------------------------- (125) TransformationProof (EQUIVALENT) By forward instantiating [JAR06] the rule U5_GGGA(s(z1), minus_out_gga(x1)) -> DIV_IN_GGA(x1, s(s(z1))) we obtained the following new rules [LPAR04]: (U5_GGGA(s(x0), minus_out_gga(s(y_0))) -> DIV_IN_GGA(s(y_0), s(s(x0))),U5_GGGA(s(x0), minus_out_gga(s(y_0))) -> DIV_IN_GGA(s(y_0), s(s(x0)))) ---------------------------------------- (126) Obligation: Q DP problem: The TRS P consists of the following rules: DIV_IN_GGA(s(x0), s(s(z0))) -> U3_GGA(s(x0), s(z0), U1_gga(le_in_gga(s(z0), x0))) U3_GGA(s(z0), s(z1), le_out_gga(x2)) -> IF_IN_GGGA(x2, s(z0), s(s(z1))) IF_IN_GGGA(true, s(x0), s(s(x1))) -> U5_GGGA(s(x1), U2_gga(minus_in_gga(x0, x1))) U5_GGGA(s(x0), minus_out_gga(s(y_0))) -> DIV_IN_GGA(s(y_0), s(s(x0))) The TRS R consists of the following rules: minus_in_gga(X, 0) -> minus_out_gga(X) minus_in_gga(s(X), s(Y)) -> U2_gga(minus_in_gga(X, Y)) le_in_gga(s(X), 0) -> le_out_gga(false) le_in_gga(s(X), s(Y)) -> U1_gga(le_in_gga(X, Y)) U2_gga(minus_out_gga(Z)) -> minus_out_gga(Z) U1_gga(le_out_gga(B)) -> le_out_gga(B) le_in_gga(0, Y) -> le_out_gga(true) The set Q consists of the following terms: minus_in_gga(x0, x1) le_in_gga(x0, x1) U2_gga(x0) U1_gga(x0) We have to consider all (P,Q,R)-chains. ---------------------------------------- (127) TransformationProof (EQUIVALENT) By forward instantiating [JAR06] the rule U3_GGA(s(z0), s(z1), le_out_gga(x2)) -> IF_IN_GGGA(x2, s(z0), s(s(z1))) we obtained the following new rules [LPAR04]: (U3_GGA(s(x0), s(x1), le_out_gga(true)) -> IF_IN_GGGA(true, s(x0), s(s(x1))),U3_GGA(s(x0), s(x1), le_out_gga(true)) -> IF_IN_GGGA(true, s(x0), s(s(x1)))) ---------------------------------------- (128) Obligation: Q DP problem: The TRS P consists of the following rules: DIV_IN_GGA(s(x0), s(s(z0))) -> U3_GGA(s(x0), s(z0), U1_gga(le_in_gga(s(z0), x0))) IF_IN_GGGA(true, s(x0), s(s(x1))) -> U5_GGGA(s(x1), U2_gga(minus_in_gga(x0, x1))) U5_GGGA(s(x0), minus_out_gga(s(y_0))) -> DIV_IN_GGA(s(y_0), s(s(x0))) U3_GGA(s(x0), s(x1), le_out_gga(true)) -> IF_IN_GGGA(true, s(x0), s(s(x1))) The TRS R consists of the following rules: minus_in_gga(X, 0) -> minus_out_gga(X) minus_in_gga(s(X), s(Y)) -> U2_gga(minus_in_gga(X, Y)) le_in_gga(s(X), 0) -> le_out_gga(false) le_in_gga(s(X), s(Y)) -> U1_gga(le_in_gga(X, Y)) U2_gga(minus_out_gga(Z)) -> minus_out_gga(Z) U1_gga(le_out_gga(B)) -> le_out_gga(B) le_in_gga(0, Y) -> le_out_gga(true) The set Q consists of the following terms: minus_in_gga(x0, x1) le_in_gga(x0, x1) U2_gga(x0) U1_gga(x0) We have to consider all (P,Q,R)-chains. ---------------------------------------- (129) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. U3_GGA(s(x0), s(x1), le_out_gga(true)) -> IF_IN_GGGA(true, s(x0), s(s(x1))) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( U1_gga_1(x_1) ) = max{0, -2} POL( U3_GGA_3(x_1, ..., x_3) ) = x_1 + 1 POL( le_in_gga_2(x_1, x_2) ) = max{0, 2x_2 - 2} POL( s_1(x_1) ) = 2x_1 + 1 POL( 0 ) = 1 POL( le_out_gga_1(x_1) ) = 2 POL( false ) = 2 POL( U2_gga_1(x_1) ) = 2x_1 POL( U5_GGGA_2(x_1, x_2) ) = x_2 + 1 POL( minus_in_gga_2(x_1, x_2) ) = x_1 POL( minus_out_gga_1(x_1) ) = x_1 POL( true ) = 1 POL( DIV_IN_GGA_2(x_1, x_2) ) = x_1 + 1 POL( IF_IN_GGGA_3(x_1, ..., x_3) ) = max{0, 2x_1 + x_2 - 2} The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: minus_in_gga(X, 0) -> minus_out_gga(X) minus_in_gga(s(X), s(Y)) -> U2_gga(minus_in_gga(X, Y)) U2_gga(minus_out_gga(Z)) -> minus_out_gga(Z) ---------------------------------------- (130) Obligation: Q DP problem: The TRS P consists of the following rules: DIV_IN_GGA(s(x0), s(s(z0))) -> U3_GGA(s(x0), s(z0), U1_gga(le_in_gga(s(z0), x0))) IF_IN_GGGA(true, s(x0), s(s(x1))) -> U5_GGGA(s(x1), U2_gga(minus_in_gga(x0, x1))) U5_GGGA(s(x0), minus_out_gga(s(y_0))) -> DIV_IN_GGA(s(y_0), s(s(x0))) The TRS R consists of the following rules: minus_in_gga(X, 0) -> minus_out_gga(X) minus_in_gga(s(X), s(Y)) -> U2_gga(minus_in_gga(X, Y)) le_in_gga(s(X), 0) -> le_out_gga(false) le_in_gga(s(X), s(Y)) -> U1_gga(le_in_gga(X, Y)) U2_gga(minus_out_gga(Z)) -> minus_out_gga(Z) U1_gga(le_out_gga(B)) -> le_out_gga(B) le_in_gga(0, Y) -> le_out_gga(true) The set Q consists of the following terms: minus_in_gga(x0, x1) le_in_gga(x0, x1) U2_gga(x0) U1_gga(x0) We have to consider all (P,Q,R)-chains. ---------------------------------------- (131) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 3 less nodes. ---------------------------------------- (132) TRUE ---------------------------------------- (133) PrologToTRSTransformerProof (SOUND) Transformed Prolog program to TRS. { "root": 27, "program": { "directives": [], "clauses": [ [ "(le (0) Y (true))", null ], [ "(le (s X) (0) (false))", null ], [ "(le (s X) (s Y) B)", "(le X Y B)" ], [ "(minus X (0) X)", null ], [ "(minus (s X) (s Y) Z)", "(minus X Y Z)" ], [ "(div X (s Y) Z)", "(',' (le (s Y) X B) (if B X (s Y) Z))" ], [ "(if (false) X (s Y) (0))", null ], [ "(if (true) X (s Y) (s Z))", "(',' (minus X Y U) (div U (s Y) Z))" ] ] }, "graph": { "nodes": { "27": { "goal": [{ "clause": -1, "scope": -1, "term": "(div T1 T2 T3)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T1", "T2" ], "free": [], "exprvars": [] } }, "28": { "goal": [{ "clause": 5, "scope": 1, "term": "(div T1 T2 T3)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T1", "T2" ], "free": [], "exprvars": [] } }, "191": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "170": { "goal": [{ "clause": 2, "scope": 2, "term": "(le (s T11) T10 X11)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11" ], "free": ["X11"], "exprvars": [] } }, "192": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "type": "Nodes", "194": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "370": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "173": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "174": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "197": { "goal": [{ "clause": 1, "scope": 3, "term": "(le T24 T25 X33)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T24", "T25" ], "free": ["X33"], "exprvars": [] } }, "198": { "goal": [{ "clause": 2, "scope": 3, "term": "(le T24 T25 X33)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T24", "T25" ], "free": ["X33"], "exprvars": [] } }, "177": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "410": { "goal": [{ "clause": -1, "scope": -1, "term": "(minus T66 T67 X84)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T66", "T67" ], "free": ["X84"], "exprvars": [] } }, "411": { "goal": [{ "clause": -1, "scope": -1, "term": "(div T72 (s T67) T69)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T67", "T72" ], "free": [], "exprvars": [] } }, "412": { "goal": [ { "clause": 3, "scope": 5, "term": "(minus T66 T67 X84)" }, { "clause": 4, "scope": 5, "term": "(minus T66 T67 X84)" } ], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T66", "T67" ], "free": ["X84"], "exprvars": [] } }, "413": { "goal": [{ "clause": 3, "scope": 5, "term": "(minus T66 T67 X84)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T66", "T67" ], "free": ["X84"], "exprvars": [] } }, "414": { "goal": [{ "clause": 4, "scope": 5, "term": "(minus T66 T67 X84)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T66", "T67" ], "free": ["X84"], "exprvars": [] } }, "415": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "416": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "417": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "418": { "goal": [{ "clause": -1, "scope": -1, "term": "(minus T84 T85 X105)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T84", "T85" ], "free": ["X105"], "exprvars": [] } }, "419": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "181": { "goal": [{ "clause": -1, "scope": -1, "term": "(le T24 T25 X33)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T24", "T25" ], "free": ["X33"], "exprvars": [] } }, "160": { "goal": [{ "clause": -1, "scope": -1, "term": "(le (s T11) T10 X11)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11" ], "free": ["X11"], "exprvars": [] } }, "182": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "161": { "goal": [{ "clause": -1, "scope": -1, "term": "(if T14 T10 (s T11) T13)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11", "T14" ], "free": [], "exprvars": [] } }, "141": { "goal": [{ "clause": -1, "scope": -1, "term": "(',' (le (s T11) T10 X11) (if X11 T10 (s T11) T13))" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11" ], "free": ["X11"], "exprvars": [] } }, "185": { "goal": [ { "clause": 0, "scope": 3, "term": "(le T24 T25 X33)" }, { "clause": 1, "scope": 3, "term": "(le T24 T25 X33)" }, { "clause": 2, "scope": 3, "term": "(le T24 T25 X33)" } ], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T24", "T25" ], "free": ["X33"], "exprvars": [] } }, "142": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "165": { "goal": [ { "clause": 0, "scope": 2, "term": "(le (s T11) T10 X11)" }, { "clause": 1, "scope": 2, "term": "(le (s T11) T10 X11)" }, { "clause": 2, "scope": 2, "term": "(le (s T11) T10 X11)" } ], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11" ], "free": ["X11"], "exprvars": [] } }, "187": { "goal": [{ "clause": 0, "scope": 3, "term": "(le T24 T25 X33)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T24", "T25" ], "free": ["X33"], "exprvars": [] } }, "188": { "goal": [ { "clause": 1, "scope": 3, "term": "(le T24 T25 X33)" }, { "clause": 2, "scope": 3, "term": "(le T24 T25 X33)" } ], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T24", "T25" ], "free": ["X33"], "exprvars": [] } }, "167": { "goal": [ { "clause": 1, "scope": 2, "term": "(le (s T11) T10 X11)" }, { "clause": 2, "scope": 2, "term": "(le (s T11) T10 X11)" } ], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11" ], "free": ["X11"], "exprvars": [] } }, "201": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "169": { "goal": [{ "clause": 1, "scope": 2, "term": "(le (s T11) T10 X11)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11" ], "free": ["X11"], "exprvars": [] } }, "202": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "204": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "369": { "goal": [{ "clause": -1, "scope": -1, "term": "(le T42 T43 X57)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T42", "T43" ], "free": ["X57"], "exprvars": [] } }, "402": { "goal": [ { "clause": 6, "scope": 4, "term": "(if T14 T10 (s T11) T13)" }, { "clause": 7, "scope": 4, "term": "(if T14 T10 (s T11) T13)" } ], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11", "T14" ], "free": [], "exprvars": [] } }, "403": { "goal": [{ "clause": 6, "scope": 4, "term": "(if T14 T10 (s T11) T13)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11", "T14" ], "free": [], "exprvars": [] } }, "404": { "goal": [{ "clause": 7, "scope": 4, "term": "(if T14 T10 (s T11) T13)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11", "T14" ], "free": [], "exprvars": [] } }, "405": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "406": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "407": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "408": { "goal": [{ "clause": -1, "scope": -1, "term": "(',' (minus T66 T67 X84) (div X84 (s T67) T69))" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T66", "T67" ], "free": ["X84"], "exprvars": [] } }, "409": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } } }, "edges": [ { "from": 27, "to": 28, "label": "CASE" }, { "from": 28, "to": 141, "label": "EVAL with clause\ndiv(X8, s(X9), X10) :- ','(le(s(X9), X8, X11), if(X11, X8, s(X9), X10)).\nand substitutionT1 -> T10,\nX8 -> T10,\nX9 -> T11,\nT2 -> s(T11),\nT3 -> T13,\nX10 -> T13,\nT12 -> T13" }, { "from": 28, "to": 142, "label": "EVAL-BACKTRACK" }, { "from": 141, "to": 160, "label": "SPLIT 1" }, { "from": 141, "to": 161, "label": "SPLIT 2\nnew knowledge:\nT11 is ground\nT10 is ground\nT14 is ground\nreplacements:X11 -> T14" }, { "from": 160, "to": 165, "label": "CASE" }, { "from": 161, "to": 402, "label": "CASE" }, { "from": 165, "to": 167, "label": "BACKTRACK\nfor clause: le(0, Y, true)because of non-unification" }, { "from": 167, "to": 169, "label": "PARALLEL" }, { "from": 167, "to": 170, "label": "PARALLEL" }, { "from": 169, "to": 173, "label": "EVAL with clause\nle(s(X21), 0, false).\nand substitutionT11 -> T19,\nX21 -> T19,\nT10 -> 0,\nX11 -> false" }, { "from": 169, "to": 174, "label": "EVAL-BACKTRACK" }, { "from": 170, "to": 181, "label": "EVAL with clause\nle(s(X30), s(X31), X32) :- le(X30, X31, X32).\nand substitutionT11 -> T24,\nX30 -> T24,\nX31 -> T25,\nT10 -> s(T25),\nX11 -> X33,\nX32 -> X33" }, { "from": 170, "to": 182, "label": "EVAL-BACKTRACK" }, { "from": 173, "to": 177, "label": "SUCCESS" }, { "from": 181, "to": 185, "label": "CASE" }, { "from": 185, "to": 187, "label": "PARALLEL" }, { "from": 185, "to": 188, "label": "PARALLEL" }, { "from": 187, "to": 191, "label": "EVAL with clause\nle(0, X40, true).\nand substitutionT24 -> 0,\nT25 -> T32,\nX40 -> T32,\nX33 -> true" }, { "from": 187, "to": 192, "label": "EVAL-BACKTRACK" }, { "from": 188, "to": 197, "label": "PARALLEL" }, { "from": 188, "to": 198, "label": "PARALLEL" }, { "from": 191, "to": 194, "label": "SUCCESS" }, { "from": 197, "to": 201, "label": "EVAL with clause\nle(s(X45), 0, false).\nand substitutionX45 -> T37,\nT24 -> s(T37),\nT25 -> 0,\nX33 -> false" }, { "from": 197, "to": 202, "label": "EVAL-BACKTRACK" }, { "from": 198, "to": 369, "label": "EVAL with clause\nle(s(X54), s(X55), X56) :- le(X54, X55, X56).\nand substitutionX54 -> T42,\nT24 -> s(T42),\nX55 -> T43,\nT25 -> s(T43),\nX33 -> X57,\nX56 -> X57" }, { "from": 198, "to": 370, "label": "EVAL-BACKTRACK" }, { "from": 201, "to": 204, "label": "SUCCESS" }, { "from": 369, "to": 181, "label": "INSTANCE with matching:\nT24 -> T42\nT25 -> T43\nX33 -> X57" }, { "from": 402, "to": 403, "label": "PARALLEL" }, { "from": 402, "to": 404, "label": "PARALLEL" }, { "from": 403, "to": 405, "label": "EVAL with clause\nif(false, X72, s(X73), 0).\nand substitutionT14 -> false,\nT10 -> T58,\nX72 -> T58,\nT11 -> T59,\nX73 -> T59,\nT13 -> 0" }, { "from": 403, "to": 406, "label": "EVAL-BACKTRACK" }, { "from": 404, "to": 408, "label": "EVAL with clause\nif(true, X81, s(X82), s(X83)) :- ','(minus(X81, X82, X84), div(X84, s(X82), X83)).\nand substitutionT14 -> true,\nT10 -> T66,\nX81 -> T66,\nT11 -> T67,\nX82 -> T67,\nX83 -> T69,\nT13 -> s(T69),\nT68 -> T69" }, { "from": 404, "to": 409, "label": "EVAL-BACKTRACK" }, { "from": 405, "to": 407, "label": "SUCCESS" }, { "from": 408, "to": 410, "label": "SPLIT 1" }, { "from": 408, "to": 411, "label": "SPLIT 2\nnew knowledge:\nT66 is ground\nT67 is ground\nT72 is ground\nreplacements:X84 -> T72" }, { "from": 410, "to": 412, "label": "CASE" }, { "from": 411, "to": 27, "label": "INSTANCE with matching:\nT1 -> T72\nT2 -> s(T67)\nT3 -> T69" }, { "from": 412, "to": 413, "label": "PARALLEL" }, { "from": 412, "to": 414, "label": "PARALLEL" }, { "from": 413, "to": 415, "label": "EVAL with clause\nminus(X93, 0, X93).\nand substitutionT66 -> T79,\nX93 -> T79,\nT67 -> 0,\nX84 -> T79" }, { "from": 413, "to": 416, "label": "EVAL-BACKTRACK" }, { "from": 414, "to": 418, "label": "EVAL with clause\nminus(s(X102), s(X103), X104) :- minus(X102, X103, X104).\nand substitutionX102 -> T84,\nT66 -> s(T84),\nX103 -> T85,\nT67 -> s(T85),\nX84 -> X105,\nX104 -> X105" }, { "from": 414, "to": 419, "label": "EVAL-BACKTRACK" }, { "from": 415, "to": 417, "label": "SUCCESS" }, { "from": 418, "to": 410, "label": "INSTANCE with matching:\nT66 -> T84\nT67 -> T85\nX84 -> X105" } ], "type": "Graph" } } ---------------------------------------- (134) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: f27_in(T10, s(T11)) -> U1(f141_in(T11, T10), T10, s(T11)) U1(f141_out1(X11, T13), T10, s(T11)) -> f27_out1(T13) f181_in(0, T32) -> f181_out1(true) f181_in(s(T37), 0) -> f181_out1(false) f181_in(s(T42), s(T43)) -> U2(f181_in(T42, T43), s(T42), s(T43)) U2(f181_out1(X57), s(T42), s(T43)) -> f181_out1(X57) f410_in(T79, 0) -> f410_out1(T79) f410_in(s(T84), s(T85)) -> U3(f410_in(T84, T85), s(T84), s(T85)) U3(f410_out1(X105), s(T84), s(T85)) -> f410_out1(X105) f160_in(T19, 0) -> f160_out1(false) f160_in(T24, s(T25)) -> U4(f181_in(T24, T25), T24, s(T25)) U4(f181_out1(X33), T24, s(T25)) -> f160_out1(X33) f161_in(false, T58, T59) -> f161_out1(0) f161_in(true, T66, T67) -> U5(f408_in(T66, T67), true, T66, T67) U5(f408_out1(X84, T69), true, T66, T67) -> f161_out1(s(T69)) f141_in(T11, T10) -> U6(f160_in(T11, T10), T11, T10) U6(f160_out1(T14), T11, T10) -> U7(f161_in(T14, T10, T11), T11, T10, T14) U7(f161_out1(T13), T11, T10, T14) -> f141_out1(T14, T13) f408_in(T66, T67) -> U8(f410_in(T66, T67), T66, T67) U8(f410_out1(T72), T66, T67) -> U9(f27_in(T72, s(T67)), T66, T67, T72) U9(f27_out1(T69), T66, T67, T72) -> f408_out1(T72, T69) Q is empty. ---------------------------------------- (135) Overlay + Local Confluence (EQUIVALENT) The TRS is overlay and locally confluent. By [NOC] we can switch to innermost. ---------------------------------------- (136) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: f27_in(T10, s(T11)) -> U1(f141_in(T11, T10), T10, s(T11)) U1(f141_out1(X11, T13), T10, s(T11)) -> f27_out1(T13) f181_in(0, T32) -> f181_out1(true) f181_in(s(T37), 0) -> f181_out1(false) f181_in(s(T42), s(T43)) -> U2(f181_in(T42, T43), s(T42), s(T43)) U2(f181_out1(X57), s(T42), s(T43)) -> f181_out1(X57) f410_in(T79, 0) -> f410_out1(T79) f410_in(s(T84), s(T85)) -> U3(f410_in(T84, T85), s(T84), s(T85)) U3(f410_out1(X105), s(T84), s(T85)) -> f410_out1(X105) f160_in(T19, 0) -> f160_out1(false) f160_in(T24, s(T25)) -> U4(f181_in(T24, T25), T24, s(T25)) U4(f181_out1(X33), T24, s(T25)) -> f160_out1(X33) f161_in(false, T58, T59) -> f161_out1(0) f161_in(true, T66, T67) -> U5(f408_in(T66, T67), true, T66, T67) U5(f408_out1(X84, T69), true, T66, T67) -> f161_out1(s(T69)) f141_in(T11, T10) -> U6(f160_in(T11, T10), T11, T10) U6(f160_out1(T14), T11, T10) -> U7(f161_in(T14, T10, T11), T11, T10, T14) U7(f161_out1(T13), T11, T10, T14) -> f141_out1(T14, T13) f408_in(T66, T67) -> U8(f410_in(T66, T67), T66, T67) U8(f410_out1(T72), T66, T67) -> U9(f27_in(T72, s(T67)), T66, T67, T72) U9(f27_out1(T69), T66, T67, T72) -> f408_out1(T72, T69) The set Q consists of the following terms: f27_in(x0, s(x1)) U1(f141_out1(x0, x1), x2, s(x3)) f181_in(0, x0) f181_in(s(x0), 0) f181_in(s(x0), s(x1)) U2(f181_out1(x0), s(x1), s(x2)) f410_in(x0, 0) f410_in(s(x0), s(x1)) U3(f410_out1(x0), s(x1), s(x2)) f160_in(x0, 0) f160_in(x0, s(x1)) U4(f181_out1(x0), x1, s(x2)) f161_in(false, x0, x1) f161_in(true, x0, x1) U5(f408_out1(x0, x1), true, x2, x3) f141_in(x0, x1) U6(f160_out1(x0), x1, x2) U7(f161_out1(x0), x1, x2, x3) f408_in(x0, x1) U8(f410_out1(x0), x1, x2) U9(f27_out1(x0), x1, x2, x3) ---------------------------------------- (137) DependencyPairsProof (EQUIVALENT) Using Dependency Pairs [AG00,LPAR04] we result in the following initial DP problem. ---------------------------------------- (138) Obligation: Q DP problem: The TRS P consists of the following rules: F27_IN(T10, s(T11)) -> U1^1(f141_in(T11, T10), T10, s(T11)) F27_IN(T10, s(T11)) -> F141_IN(T11, T10) F181_IN(s(T42), s(T43)) -> U2^1(f181_in(T42, T43), s(T42), s(T43)) F181_IN(s(T42), s(T43)) -> F181_IN(T42, T43) F410_IN(s(T84), s(T85)) -> U3^1(f410_in(T84, T85), s(T84), s(T85)) F410_IN(s(T84), s(T85)) -> F410_IN(T84, T85) F160_IN(T24, s(T25)) -> U4^1(f181_in(T24, T25), T24, s(T25)) F160_IN(T24, s(T25)) -> F181_IN(T24, T25) F161_IN(true, T66, T67) -> U5^1(f408_in(T66, T67), true, T66, T67) F161_IN(true, T66, T67) -> F408_IN(T66, T67) F141_IN(T11, T10) -> U6^1(f160_in(T11, T10), T11, T10) F141_IN(T11, T10) -> F160_IN(T11, T10) U6^1(f160_out1(T14), T11, T10) -> U7^1(f161_in(T14, T10, T11), T11, T10, T14) U6^1(f160_out1(T14), T11, T10) -> F161_IN(T14, T10, T11) F408_IN(T66, T67) -> U8^1(f410_in(T66, T67), T66, T67) F408_IN(T66, T67) -> F410_IN(T66, T67) U8^1(f410_out1(T72), T66, T67) -> U9^1(f27_in(T72, s(T67)), T66, T67, T72) U8^1(f410_out1(T72), T66, T67) -> F27_IN(T72, s(T67)) The TRS R consists of the following rules: f27_in(T10, s(T11)) -> U1(f141_in(T11, T10), T10, s(T11)) U1(f141_out1(X11, T13), T10, s(T11)) -> f27_out1(T13) f181_in(0, T32) -> f181_out1(true) f181_in(s(T37), 0) -> f181_out1(false) f181_in(s(T42), s(T43)) -> U2(f181_in(T42, T43), s(T42), s(T43)) U2(f181_out1(X57), s(T42), s(T43)) -> f181_out1(X57) f410_in(T79, 0) -> f410_out1(T79) f410_in(s(T84), s(T85)) -> U3(f410_in(T84, T85), s(T84), s(T85)) U3(f410_out1(X105), s(T84), s(T85)) -> f410_out1(X105) f160_in(T19, 0) -> f160_out1(false) f160_in(T24, s(T25)) -> U4(f181_in(T24, T25), T24, s(T25)) U4(f181_out1(X33), T24, s(T25)) -> f160_out1(X33) f161_in(false, T58, T59) -> f161_out1(0) f161_in(true, T66, T67) -> U5(f408_in(T66, T67), true, T66, T67) U5(f408_out1(X84, T69), true, T66, T67) -> f161_out1(s(T69)) f141_in(T11, T10) -> U6(f160_in(T11, T10), T11, T10) U6(f160_out1(T14), T11, T10) -> U7(f161_in(T14, T10, T11), T11, T10, T14) U7(f161_out1(T13), T11, T10, T14) -> f141_out1(T14, T13) f408_in(T66, T67) -> U8(f410_in(T66, T67), T66, T67) U8(f410_out1(T72), T66, T67) -> U9(f27_in(T72, s(T67)), T66, T67, T72) U9(f27_out1(T69), T66, T67, T72) -> f408_out1(T72, T69) The set Q consists of the following terms: f27_in(x0, s(x1)) U1(f141_out1(x0, x1), x2, s(x3)) f181_in(0, x0) f181_in(s(x0), 0) f181_in(s(x0), s(x1)) U2(f181_out1(x0), s(x1), s(x2)) f410_in(x0, 0) f410_in(s(x0), s(x1)) U3(f410_out1(x0), s(x1), s(x2)) f160_in(x0, 0) f160_in(x0, s(x1)) U4(f181_out1(x0), x1, s(x2)) f161_in(false, x0, x1) f161_in(true, x0, x1) U5(f408_out1(x0, x1), true, x2, x3) f141_in(x0, x1) U6(f160_out1(x0), x1, x2) U7(f161_out1(x0), x1, x2, x3) f408_in(x0, x1) U8(f410_out1(x0), x1, x2) U9(f27_out1(x0), x1, x2, x3) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (139) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 3 SCCs with 10 less nodes. ---------------------------------------- (140) Complex Obligation (AND) ---------------------------------------- (141) Obligation: Q DP problem: The TRS P consists of the following rules: F410_IN(s(T84), s(T85)) -> F410_IN(T84, T85) The TRS R consists of the following rules: f27_in(T10, s(T11)) -> U1(f141_in(T11, T10), T10, s(T11)) U1(f141_out1(X11, T13), T10, s(T11)) -> f27_out1(T13) f181_in(0, T32) -> f181_out1(true) f181_in(s(T37), 0) -> f181_out1(false) f181_in(s(T42), s(T43)) -> U2(f181_in(T42, T43), s(T42), s(T43)) U2(f181_out1(X57), s(T42), s(T43)) -> f181_out1(X57) f410_in(T79, 0) -> f410_out1(T79) f410_in(s(T84), s(T85)) -> U3(f410_in(T84, T85), s(T84), s(T85)) U3(f410_out1(X105), s(T84), s(T85)) -> f410_out1(X105) f160_in(T19, 0) -> f160_out1(false) f160_in(T24, s(T25)) -> U4(f181_in(T24, T25), T24, s(T25)) U4(f181_out1(X33), T24, s(T25)) -> f160_out1(X33) f161_in(false, T58, T59) -> f161_out1(0) f161_in(true, T66, T67) -> U5(f408_in(T66, T67), true, T66, T67) U5(f408_out1(X84, T69), true, T66, T67) -> f161_out1(s(T69)) f141_in(T11, T10) -> U6(f160_in(T11, T10), T11, T10) U6(f160_out1(T14), T11, T10) -> U7(f161_in(T14, T10, T11), T11, T10, T14) U7(f161_out1(T13), T11, T10, T14) -> f141_out1(T14, T13) f408_in(T66, T67) -> U8(f410_in(T66, T67), T66, T67) U8(f410_out1(T72), T66, T67) -> U9(f27_in(T72, s(T67)), T66, T67, T72) U9(f27_out1(T69), T66, T67, T72) -> f408_out1(T72, T69) The set Q consists of the following terms: f27_in(x0, s(x1)) U1(f141_out1(x0, x1), x2, s(x3)) f181_in(0, x0) f181_in(s(x0), 0) f181_in(s(x0), s(x1)) U2(f181_out1(x0), s(x1), s(x2)) f410_in(x0, 0) f410_in(s(x0), s(x1)) U3(f410_out1(x0), s(x1), s(x2)) f160_in(x0, 0) f160_in(x0, s(x1)) U4(f181_out1(x0), x1, s(x2)) f161_in(false, x0, x1) f161_in(true, x0, x1) U5(f408_out1(x0, x1), true, x2, x3) f141_in(x0, x1) U6(f160_out1(x0), x1, x2) U7(f161_out1(x0), x1, x2, x3) f408_in(x0, x1) U8(f410_out1(x0), x1, x2) U9(f27_out1(x0), x1, x2, x3) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (142) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (143) Obligation: Q DP problem: The TRS P consists of the following rules: F410_IN(s(T84), s(T85)) -> F410_IN(T84, T85) R is empty. The set Q consists of the following terms: f27_in(x0, s(x1)) U1(f141_out1(x0, x1), x2, s(x3)) f181_in(0, x0) f181_in(s(x0), 0) f181_in(s(x0), s(x1)) U2(f181_out1(x0), s(x1), s(x2)) f410_in(x0, 0) f410_in(s(x0), s(x1)) U3(f410_out1(x0), s(x1), s(x2)) f160_in(x0, 0) f160_in(x0, s(x1)) U4(f181_out1(x0), x1, s(x2)) f161_in(false, x0, x1) f161_in(true, x0, x1) U5(f408_out1(x0, x1), true, x2, x3) f141_in(x0, x1) U6(f160_out1(x0), x1, x2) U7(f161_out1(x0), x1, x2, x3) f408_in(x0, x1) U8(f410_out1(x0), x1, x2) U9(f27_out1(x0), x1, x2, x3) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (144) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. f27_in(x0, s(x1)) U1(f141_out1(x0, x1), x2, s(x3)) f181_in(0, x0) f181_in(s(x0), 0) f181_in(s(x0), s(x1)) U2(f181_out1(x0), s(x1), s(x2)) f410_in(x0, 0) f410_in(s(x0), s(x1)) U3(f410_out1(x0), s(x1), s(x2)) f160_in(x0, 0) f160_in(x0, s(x1)) U4(f181_out1(x0), x1, s(x2)) f161_in(false, x0, x1) f161_in(true, x0, x1) U5(f408_out1(x0, x1), true, x2, x3) f141_in(x0, x1) U6(f160_out1(x0), x1, x2) U7(f161_out1(x0), x1, x2, x3) f408_in(x0, x1) U8(f410_out1(x0), x1, x2) U9(f27_out1(x0), x1, x2, x3) ---------------------------------------- (145) Obligation: Q DP problem: The TRS P consists of the following rules: F410_IN(s(T84), s(T85)) -> F410_IN(T84, T85) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (146) 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: *F410_IN(s(T84), s(T85)) -> F410_IN(T84, T85) The graph contains the following edges 1 > 1, 2 > 2 ---------------------------------------- (147) YES ---------------------------------------- (148) Obligation: Q DP problem: The TRS P consists of the following rules: F181_IN(s(T42), s(T43)) -> F181_IN(T42, T43) The TRS R consists of the following rules: f27_in(T10, s(T11)) -> U1(f141_in(T11, T10), T10, s(T11)) U1(f141_out1(X11, T13), T10, s(T11)) -> f27_out1(T13) f181_in(0, T32) -> f181_out1(true) f181_in(s(T37), 0) -> f181_out1(false) f181_in(s(T42), s(T43)) -> U2(f181_in(T42, T43), s(T42), s(T43)) U2(f181_out1(X57), s(T42), s(T43)) -> f181_out1(X57) f410_in(T79, 0) -> f410_out1(T79) f410_in(s(T84), s(T85)) -> U3(f410_in(T84, T85), s(T84), s(T85)) U3(f410_out1(X105), s(T84), s(T85)) -> f410_out1(X105) f160_in(T19, 0) -> f160_out1(false) f160_in(T24, s(T25)) -> U4(f181_in(T24, T25), T24, s(T25)) U4(f181_out1(X33), T24, s(T25)) -> f160_out1(X33) f161_in(false, T58, T59) -> f161_out1(0) f161_in(true, T66, T67) -> U5(f408_in(T66, T67), true, T66, T67) U5(f408_out1(X84, T69), true, T66, T67) -> f161_out1(s(T69)) f141_in(T11, T10) -> U6(f160_in(T11, T10), T11, T10) U6(f160_out1(T14), T11, T10) -> U7(f161_in(T14, T10, T11), T11, T10, T14) U7(f161_out1(T13), T11, T10, T14) -> f141_out1(T14, T13) f408_in(T66, T67) -> U8(f410_in(T66, T67), T66, T67) U8(f410_out1(T72), T66, T67) -> U9(f27_in(T72, s(T67)), T66, T67, T72) U9(f27_out1(T69), T66, T67, T72) -> f408_out1(T72, T69) The set Q consists of the following terms: f27_in(x0, s(x1)) U1(f141_out1(x0, x1), x2, s(x3)) f181_in(0, x0) f181_in(s(x0), 0) f181_in(s(x0), s(x1)) U2(f181_out1(x0), s(x1), s(x2)) f410_in(x0, 0) f410_in(s(x0), s(x1)) U3(f410_out1(x0), s(x1), s(x2)) f160_in(x0, 0) f160_in(x0, s(x1)) U4(f181_out1(x0), x1, s(x2)) f161_in(false, x0, x1) f161_in(true, x0, x1) U5(f408_out1(x0, x1), true, x2, x3) f141_in(x0, x1) U6(f160_out1(x0), x1, x2) U7(f161_out1(x0), x1, x2, x3) f408_in(x0, x1) U8(f410_out1(x0), x1, x2) U9(f27_out1(x0), x1, x2, x3) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (149) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (150) Obligation: Q DP problem: The TRS P consists of the following rules: F181_IN(s(T42), s(T43)) -> F181_IN(T42, T43) R is empty. The set Q consists of the following terms: f27_in(x0, s(x1)) U1(f141_out1(x0, x1), x2, s(x3)) f181_in(0, x0) f181_in(s(x0), 0) f181_in(s(x0), s(x1)) U2(f181_out1(x0), s(x1), s(x2)) f410_in(x0, 0) f410_in(s(x0), s(x1)) U3(f410_out1(x0), s(x1), s(x2)) f160_in(x0, 0) f160_in(x0, s(x1)) U4(f181_out1(x0), x1, s(x2)) f161_in(false, x0, x1) f161_in(true, x0, x1) U5(f408_out1(x0, x1), true, x2, x3) f141_in(x0, x1) U6(f160_out1(x0), x1, x2) U7(f161_out1(x0), x1, x2, x3) f408_in(x0, x1) U8(f410_out1(x0), x1, x2) U9(f27_out1(x0), x1, x2, x3) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (151) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. f27_in(x0, s(x1)) U1(f141_out1(x0, x1), x2, s(x3)) f181_in(0, x0) f181_in(s(x0), 0) f181_in(s(x0), s(x1)) U2(f181_out1(x0), s(x1), s(x2)) f410_in(x0, 0) f410_in(s(x0), s(x1)) U3(f410_out1(x0), s(x1), s(x2)) f160_in(x0, 0) f160_in(x0, s(x1)) U4(f181_out1(x0), x1, s(x2)) f161_in(false, x0, x1) f161_in(true, x0, x1) U5(f408_out1(x0, x1), true, x2, x3) f141_in(x0, x1) U6(f160_out1(x0), x1, x2) U7(f161_out1(x0), x1, x2, x3) f408_in(x0, x1) U8(f410_out1(x0), x1, x2) U9(f27_out1(x0), x1, x2, x3) ---------------------------------------- (152) Obligation: Q DP problem: The TRS P consists of the following rules: F181_IN(s(T42), s(T43)) -> F181_IN(T42, T43) R is empty. Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (153) 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: *F181_IN(s(T42), s(T43)) -> F181_IN(T42, T43) The graph contains the following edges 1 > 1, 2 > 2 ---------------------------------------- (154) YES ---------------------------------------- (155) Obligation: Q DP problem: The TRS P consists of the following rules: F27_IN(T10, s(T11)) -> F141_IN(T11, T10) F141_IN(T11, T10) -> U6^1(f160_in(T11, T10), T11, T10) U6^1(f160_out1(T14), T11, T10) -> F161_IN(T14, T10, T11) F161_IN(true, T66, T67) -> F408_IN(T66, T67) F408_IN(T66, T67) -> U8^1(f410_in(T66, T67), T66, T67) U8^1(f410_out1(T72), T66, T67) -> F27_IN(T72, s(T67)) The TRS R consists of the following rules: f27_in(T10, s(T11)) -> U1(f141_in(T11, T10), T10, s(T11)) U1(f141_out1(X11, T13), T10, s(T11)) -> f27_out1(T13) f181_in(0, T32) -> f181_out1(true) f181_in(s(T37), 0) -> f181_out1(false) f181_in(s(T42), s(T43)) -> U2(f181_in(T42, T43), s(T42), s(T43)) U2(f181_out1(X57), s(T42), s(T43)) -> f181_out1(X57) f410_in(T79, 0) -> f410_out1(T79) f410_in(s(T84), s(T85)) -> U3(f410_in(T84, T85), s(T84), s(T85)) U3(f410_out1(X105), s(T84), s(T85)) -> f410_out1(X105) f160_in(T19, 0) -> f160_out1(false) f160_in(T24, s(T25)) -> U4(f181_in(T24, T25), T24, s(T25)) U4(f181_out1(X33), T24, s(T25)) -> f160_out1(X33) f161_in(false, T58, T59) -> f161_out1(0) f161_in(true, T66, T67) -> U5(f408_in(T66, T67), true, T66, T67) U5(f408_out1(X84, T69), true, T66, T67) -> f161_out1(s(T69)) f141_in(T11, T10) -> U6(f160_in(T11, T10), T11, T10) U6(f160_out1(T14), T11, T10) -> U7(f161_in(T14, T10, T11), T11, T10, T14) U7(f161_out1(T13), T11, T10, T14) -> f141_out1(T14, T13) f408_in(T66, T67) -> U8(f410_in(T66, T67), T66, T67) U8(f410_out1(T72), T66, T67) -> U9(f27_in(T72, s(T67)), T66, T67, T72) U9(f27_out1(T69), T66, T67, T72) -> f408_out1(T72, T69) The set Q consists of the following terms: f27_in(x0, s(x1)) U1(f141_out1(x0, x1), x2, s(x3)) f181_in(0, x0) f181_in(s(x0), 0) f181_in(s(x0), s(x1)) U2(f181_out1(x0), s(x1), s(x2)) f410_in(x0, 0) f410_in(s(x0), s(x1)) U3(f410_out1(x0), s(x1), s(x2)) f160_in(x0, 0) f160_in(x0, s(x1)) U4(f181_out1(x0), x1, s(x2)) f161_in(false, x0, x1) f161_in(true, x0, x1) U5(f408_out1(x0, x1), true, x2, x3) f141_in(x0, x1) U6(f160_out1(x0), x1, x2) U7(f161_out1(x0), x1, x2, x3) f408_in(x0, x1) U8(f410_out1(x0), x1, x2) U9(f27_out1(x0), x1, x2, x3) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (156) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (157) Obligation: Q DP problem: The TRS P consists of the following rules: F27_IN(T10, s(T11)) -> F141_IN(T11, T10) F141_IN(T11, T10) -> U6^1(f160_in(T11, T10), T11, T10) U6^1(f160_out1(T14), T11, T10) -> F161_IN(T14, T10, T11) F161_IN(true, T66, T67) -> F408_IN(T66, T67) F408_IN(T66, T67) -> U8^1(f410_in(T66, T67), T66, T67) U8^1(f410_out1(T72), T66, T67) -> F27_IN(T72, s(T67)) The TRS R consists of the following rules: f410_in(T79, 0) -> f410_out1(T79) f410_in(s(T84), s(T85)) -> U3(f410_in(T84, T85), s(T84), s(T85)) U3(f410_out1(X105), s(T84), s(T85)) -> f410_out1(X105) f160_in(T19, 0) -> f160_out1(false) f160_in(T24, s(T25)) -> U4(f181_in(T24, T25), T24, s(T25)) f181_in(0, T32) -> f181_out1(true) f181_in(s(T37), 0) -> f181_out1(false) f181_in(s(T42), s(T43)) -> U2(f181_in(T42, T43), s(T42), s(T43)) U4(f181_out1(X33), T24, s(T25)) -> f160_out1(X33) U2(f181_out1(X57), s(T42), s(T43)) -> f181_out1(X57) The set Q consists of the following terms: f27_in(x0, s(x1)) U1(f141_out1(x0, x1), x2, s(x3)) f181_in(0, x0) f181_in(s(x0), 0) f181_in(s(x0), s(x1)) U2(f181_out1(x0), s(x1), s(x2)) f410_in(x0, 0) f410_in(s(x0), s(x1)) U3(f410_out1(x0), s(x1), s(x2)) f160_in(x0, 0) f160_in(x0, s(x1)) U4(f181_out1(x0), x1, s(x2)) f161_in(false, x0, x1) f161_in(true, x0, x1) U5(f408_out1(x0, x1), true, x2, x3) f141_in(x0, x1) U6(f160_out1(x0), x1, x2) U7(f161_out1(x0), x1, x2, x3) f408_in(x0, x1) U8(f410_out1(x0), x1, x2) U9(f27_out1(x0), x1, x2, x3) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (158) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. f27_in(x0, s(x1)) U1(f141_out1(x0, x1), x2, s(x3)) f161_in(false, x0, x1) f161_in(true, x0, x1) U5(f408_out1(x0, x1), true, x2, x3) f141_in(x0, x1) U6(f160_out1(x0), x1, x2) U7(f161_out1(x0), x1, x2, x3) f408_in(x0, x1) U8(f410_out1(x0), x1, x2) U9(f27_out1(x0), x1, x2, x3) ---------------------------------------- (159) Obligation: Q DP problem: The TRS P consists of the following rules: F27_IN(T10, s(T11)) -> F141_IN(T11, T10) F141_IN(T11, T10) -> U6^1(f160_in(T11, T10), T11, T10) U6^1(f160_out1(T14), T11, T10) -> F161_IN(T14, T10, T11) F161_IN(true, T66, T67) -> F408_IN(T66, T67) F408_IN(T66, T67) -> U8^1(f410_in(T66, T67), T66, T67) U8^1(f410_out1(T72), T66, T67) -> F27_IN(T72, s(T67)) The TRS R consists of the following rules: f410_in(T79, 0) -> f410_out1(T79) f410_in(s(T84), s(T85)) -> U3(f410_in(T84, T85), s(T84), s(T85)) U3(f410_out1(X105), s(T84), s(T85)) -> f410_out1(X105) f160_in(T19, 0) -> f160_out1(false) f160_in(T24, s(T25)) -> U4(f181_in(T24, T25), T24, s(T25)) f181_in(0, T32) -> f181_out1(true) f181_in(s(T37), 0) -> f181_out1(false) f181_in(s(T42), s(T43)) -> U2(f181_in(T42, T43), s(T42), s(T43)) U4(f181_out1(X33), T24, s(T25)) -> f160_out1(X33) U2(f181_out1(X57), s(T42), s(T43)) -> f181_out1(X57) The set Q consists of the following terms: f181_in(0, x0) f181_in(s(x0), 0) f181_in(s(x0), s(x1)) U2(f181_out1(x0), s(x1), s(x2)) f410_in(x0, 0) f410_in(s(x0), s(x1)) U3(f410_out1(x0), s(x1), s(x2)) f160_in(x0, 0) f160_in(x0, s(x1)) U4(f181_out1(x0), x1, s(x2)) We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (160) MNOCProof (EQUIVALENT) We use the modular non-overlap check [FROCOS05] to decrease Q to the empty set. ---------------------------------------- (161) Obligation: Q DP problem: The TRS P consists of the following rules: F27_IN(T10, s(T11)) -> F141_IN(T11, T10) F141_IN(T11, T10) -> U6^1(f160_in(T11, T10), T11, T10) U6^1(f160_out1(T14), T11, T10) -> F161_IN(T14, T10, T11) F161_IN(true, T66, T67) -> F408_IN(T66, T67) F408_IN(T66, T67) -> U8^1(f410_in(T66, T67), T66, T67) U8^1(f410_out1(T72), T66, T67) -> F27_IN(T72, s(T67)) The TRS R consists of the following rules: f410_in(T79, 0) -> f410_out1(T79) f410_in(s(T84), s(T85)) -> U3(f410_in(T84, T85), s(T84), s(T85)) U3(f410_out1(X105), s(T84), s(T85)) -> f410_out1(X105) f160_in(T19, 0) -> f160_out1(false) f160_in(T24, s(T25)) -> U4(f181_in(T24, T25), T24, s(T25)) f181_in(0, T32) -> f181_out1(true) f181_in(s(T37), 0) -> f181_out1(false) f181_in(s(T42), s(T43)) -> U2(f181_in(T42, T43), s(T42), s(T43)) U4(f181_out1(X33), T24, s(T25)) -> f160_out1(X33) U2(f181_out1(X57), s(T42), s(T43)) -> f181_out1(X57) Q is empty. We have to consider all (P,Q,R)-chains. ---------------------------------------- (162) 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 = F141_IN(0, s(T25')) evaluates to t =F141_IN(0, s(T25')) Thus s starts an infinite chain as s semiunifies with t with the following substitutions: * Matcher: [ ] * Semiunifier: [ ] -------------------------------------------------------------------------------- Rewriting sequence F141_IN(0, s(T25')) -> U6^1(f160_in(0, s(T25')), 0, s(T25')) with rule F141_IN(T11, T10') -> U6^1(f160_in(T11, T10'), T11, T10') at position [] and matcher [T11 / 0, T10' / s(T25')] U6^1(f160_in(0, s(T25')), 0, s(T25')) -> U6^1(U4(f181_in(0, T25'), 0, s(T25')), 0, s(T25')) with rule f160_in(T24', s(T25'')) -> U4(f181_in(T24', T25''), T24', s(T25'')) at position [0] and matcher [T24' / 0, T25'' / T25'] U6^1(U4(f181_in(0, T25'), 0, s(T25')), 0, s(T25')) -> U6^1(U4(f181_out1(true), 0, s(T25')), 0, s(T25')) with rule f181_in(0, T32) -> f181_out1(true) at position [0,0] and matcher [T32 / T25'] U6^1(U4(f181_out1(true), 0, s(T25')), 0, s(T25')) -> U6^1(f160_out1(true), 0, s(T25')) with rule U4(f181_out1(X33), T24, s(T25)) -> f160_out1(X33) at position [0] and matcher [X33 / true, T24 / 0, T25 / T25'] U6^1(f160_out1(true), 0, s(T25')) -> F161_IN(true, s(T25'), 0) with rule U6^1(f160_out1(T14), T11, T10) -> F161_IN(T14, T10, T11) at position [] and matcher [T14 / true, T11 / 0, T10 / s(T25')] F161_IN(true, s(T25'), 0) -> F408_IN(s(T25'), 0) with rule F161_IN(true, T66, T67) -> F408_IN(T66, T67) at position [] and matcher [T66 / s(T25'), T67 / 0] F408_IN(s(T25'), 0) -> U8^1(f410_in(s(T25'), 0), s(T25'), 0) with rule F408_IN(T66', T67') -> U8^1(f410_in(T66', T67'), T66', T67') at position [] and matcher [T66' / s(T25'), T67' / 0] U8^1(f410_in(s(T25'), 0), s(T25'), 0) -> U8^1(f410_out1(s(T25')), s(T25'), 0) with rule f410_in(T79, 0) -> f410_out1(T79) at position [0] and matcher [T79 / s(T25')] U8^1(f410_out1(s(T25')), s(T25'), 0) -> F27_IN(s(T25'), s(0)) with rule U8^1(f410_out1(T72), T66, T67) -> F27_IN(T72, s(T67)) at position [] and matcher [T72 / s(T25'), T66 / s(T25'), T67 / 0] F27_IN(s(T25'), s(0)) -> F141_IN(0, s(T25')) with rule F27_IN(T10, s(T11)) -> F141_IN(T11, T10) 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. ---------------------------------------- (163) NO ---------------------------------------- (164) PrologToIRSwTTransformerProof (SOUND) Transformed Prolog program to IRSwT according to method in Master Thesis of A. Weinert { "root": 29, "program": { "directives": [], "clauses": [ [ "(le (0) Y (true))", null ], [ "(le (s X) (0) (false))", null ], [ "(le (s X) (s Y) B)", "(le X Y B)" ], [ "(minus X (0) X)", null ], [ "(minus (s X) (s Y) Z)", "(minus X Y Z)" ], [ "(div X (s Y) Z)", "(',' (le (s Y) X B) (if B X (s Y) Z))" ], [ "(if (false) X (s Y) (0))", null ], [ "(if (true) X (s Y) (s Z))", "(',' (minus X Y U) (div U (s Y) Z))" ] ] }, "graph": { "nodes": { "29": { "goal": [{ "clause": -1, "scope": -1, "term": "(div T1 T2 T3)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T1", "T2" ], "free": [], "exprvars": [] } }, "190": { "goal": [ { "clause": 1, "scope": 3, "term": "(le T24 T25 X33)" }, { "clause": 2, "scope": 3, "term": "(le T24 T25 X33)" } ], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T24", "T25" ], "free": ["X33"], "exprvars": [] } }, "390": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "171": { "goal": [ { "clause": 0, "scope": 2, "term": "(le (s T11) T10 X11)" }, { "clause": 1, "scope": 2, "term": "(le (s T11) T10 X11)" }, { "clause": 2, "scope": 2, "term": "(le (s T11) T10 X11)" } ], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11" ], "free": ["X11"], "exprvars": [] } }, "193": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "391": { "goal": [{ "clause": -1, "scope": -1, "term": "(minus T66 T67 X84)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T66", "T67" ], "free": ["X84"], "exprvars": [] } }, "type": "Nodes", "172": { "goal": [ { "clause": 1, "scope": 2, "term": "(le (s T11) T10 X11)" }, { "clause": 2, "scope": 2, "term": "(le (s T11) T10 X11)" } ], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11" ], "free": ["X11"], "exprvars": [] } }, "392": { "goal": [{ "clause": -1, "scope": -1, "term": "(div T72 (s T67) T69)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T67", "T72" ], "free": [], "exprvars": [] } }, "195": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "250": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "371": { "goal": [ { "clause": 6, "scope": 4, "term": "(if T14 T10 (s T11) T13)" }, { "clause": 7, "scope": 4, "term": "(if T14 T10 (s T11) T13)" } ], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11", "T14" ], "free": [], "exprvars": [] } }, "393": { "goal": [ { "clause": 3, "scope": 5, "term": "(minus T66 T67 X84)" }, { "clause": 4, "scope": 5, "term": "(minus T66 T67 X84)" } ], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T66", "T67" ], "free": ["X84"], "exprvars": [] } }, "130": { "goal": [{ "clause": -1, "scope": -1, "term": "(',' (le (s T11) T10 X11) (if X11 T10 (s T11) T13))" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11" ], "free": ["X11"], "exprvars": [] } }, "196": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "372": { "goal": [{ "clause": 6, "scope": 4, "term": "(if T14 T10 (s T11) T13)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11", "T14" ], "free": [], "exprvars": [] } }, "394": { "goal": [{ "clause": 3, "scope": 5, "term": "(minus T66 T67 X84)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T66", "T67" ], "free": ["X84"], "exprvars": [] } }, "131": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "175": { "goal": [{ "clause": 1, "scope": 2, "term": "(le (s T11) T10 X11)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11" ], "free": ["X11"], "exprvars": [] } }, "373": { "goal": [{ "clause": 7, "scope": 4, "term": "(if T14 T10 (s T11) T13)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11", "T14" ], "free": [], "exprvars": [] } }, "395": { "goal": [{ "clause": 4, "scope": 5, "term": "(minus T66 T67 X84)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T66", "T67" ], "free": ["X84"], "exprvars": [] } }, "176": { "goal": [{ "clause": 2, "scope": 2, "term": "(le (s T11) T10 X11)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11" ], "free": ["X11"], "exprvars": [] } }, "374": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "396": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "199": { "goal": [{ "clause": 1, "scope": 3, "term": "(le T24 T25 X33)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T24", "T25" ], "free": ["X33"], "exprvars": [] } }, "375": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "397": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "178": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "376": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "398": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "179": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "399": { "goal": [{ "clause": -1, "scope": -1, "term": "(minus T84 T85 X105)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T84", "T85" ], "free": ["X105"], "exprvars": [] } }, "239": { "goal": [{ "clause": -1, "scope": -1, "term": "(le T42 T43 X57)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T42", "T43" ], "free": ["X57"], "exprvars": [] } }, "30": { "goal": [{ "clause": 5, "scope": 1, "term": "(div T1 T2 T3)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T1", "T2" ], "free": [], "exprvars": [] } }, "180": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "183": { "goal": [{ "clause": -1, "scope": -1, "term": "(le T24 T25 X33)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T24", "T25" ], "free": ["X33"], "exprvars": [] } }, "162": { "goal": [{ "clause": -1, "scope": -1, "term": "(le (s T11) T10 X11)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11" ], "free": ["X11"], "exprvars": [] } }, "184": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "163": { "goal": [{ "clause": -1, "scope": -1, "term": "(if T14 T10 (s T11) T13)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11", "T14" ], "free": [], "exprvars": [] } }, "186": { "goal": [ { "clause": 0, "scope": 3, "term": "(le T24 T25 X33)" }, { "clause": 1, "scope": 3, "term": "(le T24 T25 X33)" }, { "clause": 2, "scope": 3, "term": "(le T24 T25 X33)" } ], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T24", "T25" ], "free": ["X33"], "exprvars": [] } }, "189": { "goal": [{ "clause": 0, "scope": 3, "term": "(le T24 T25 X33)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T24", "T25" ], "free": ["X33"], "exprvars": [] } }, "200": { "goal": [{ "clause": 2, "scope": 3, "term": "(le T24 T25 X33)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T24", "T25" ], "free": ["X33"], "exprvars": [] } }, "389": { "goal": [{ "clause": -1, "scope": -1, "term": "(',' (minus T66 T67 X84) (div X84 (s T67) T69))" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T66", "T67" ], "free": ["X84"], "exprvars": [] } }, "400": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "203": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "205": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "206": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } } }, "edges": [ { "from": 29, "to": 30, "label": "CASE" }, { "from": 30, "to": 130, "label": "EVAL with clause\ndiv(X8, s(X9), X10) :- ','(le(s(X9), X8, X11), if(X11, X8, s(X9), X10)).\nand substitutionT1 -> T10,\nX8 -> T10,\nX9 -> T11,\nT2 -> s(T11),\nT3 -> T13,\nX10 -> T13,\nT12 -> T13" }, { "from": 30, "to": 131, "label": "EVAL-BACKTRACK" }, { "from": 130, "to": 162, "label": "SPLIT 1" }, { "from": 130, "to": 163, "label": "SPLIT 2\nnew knowledge:\nT11 is ground\nT10 is ground\nT14 is ground\nreplacements:X11 -> T14" }, { "from": 162, "to": 171, "label": "CASE" }, { "from": 163, "to": 371, "label": "CASE" }, { "from": 171, "to": 172, "label": "BACKTRACK\nfor clause: le(0, Y, true)because of non-unification" }, { "from": 172, "to": 175, "label": "PARALLEL" }, { "from": 172, "to": 176, "label": "PARALLEL" }, { "from": 175, "to": 178, "label": "EVAL with clause\nle(s(X21), 0, false).\nand substitutionT11 -> T19,\nX21 -> T19,\nT10 -> 0,\nX11 -> false" }, { "from": 175, "to": 179, "label": "EVAL-BACKTRACK" }, { "from": 176, "to": 183, "label": "EVAL with clause\nle(s(X30), s(X31), X32) :- le(X30, X31, X32).\nand substitutionT11 -> T24,\nX30 -> T24,\nX31 -> T25,\nT10 -> s(T25),\nX11 -> X33,\nX32 -> X33" }, { "from": 176, "to": 184, "label": "EVAL-BACKTRACK" }, { "from": 178, "to": 180, "label": "SUCCESS" }, { "from": 183, "to": 186, "label": "CASE" }, { "from": 186, "to": 189, "label": "PARALLEL" }, { "from": 186, "to": 190, "label": "PARALLEL" }, { "from": 189, "to": 193, "label": "EVAL with clause\nle(0, X40, true).\nand substitutionT24 -> 0,\nT25 -> T32,\nX40 -> T32,\nX33 -> true" }, { "from": 189, "to": 195, "label": "EVAL-BACKTRACK" }, { "from": 190, "to": 199, "label": "PARALLEL" }, { "from": 190, "to": 200, "label": "PARALLEL" }, { "from": 193, "to": 196, "label": "SUCCESS" }, { "from": 199, "to": 203, "label": "EVAL with clause\nle(s(X45), 0, false).\nand substitutionX45 -> T37,\nT24 -> s(T37),\nT25 -> 0,\nX33 -> false" }, { "from": 199, "to": 205, "label": "EVAL-BACKTRACK" }, { "from": 200, "to": 239, "label": "EVAL with clause\nle(s(X54), s(X55), X56) :- le(X54, X55, X56).\nand substitutionX54 -> T42,\nT24 -> s(T42),\nX55 -> T43,\nT25 -> s(T43),\nX33 -> X57,\nX56 -> X57" }, { "from": 200, "to": 250, "label": "EVAL-BACKTRACK" }, { "from": 203, "to": 206, "label": "SUCCESS" }, { "from": 239, "to": 183, "label": "INSTANCE with matching:\nT24 -> T42\nT25 -> T43\nX33 -> X57" }, { "from": 371, "to": 372, "label": "PARALLEL" }, { "from": 371, "to": 373, "label": "PARALLEL" }, { "from": 372, "to": 374, "label": "EVAL with clause\nif(false, X72, s(X73), 0).\nand substitutionT14 -> false,\nT10 -> T58,\nX72 -> T58,\nT11 -> T59,\nX73 -> T59,\nT13 -> 0" }, { "from": 372, "to": 375, "label": "EVAL-BACKTRACK" }, { "from": 373, "to": 389, "label": "EVAL with clause\nif(true, X81, s(X82), s(X83)) :- ','(minus(X81, X82, X84), div(X84, s(X82), X83)).\nand substitutionT14 -> true,\nT10 -> T66,\nX81 -> T66,\nT11 -> T67,\nX82 -> T67,\nX83 -> T69,\nT13 -> s(T69),\nT68 -> T69" }, { "from": 373, "to": 390, "label": "EVAL-BACKTRACK" }, { "from": 374, "to": 376, "label": "SUCCESS" }, { "from": 389, "to": 391, "label": "SPLIT 1" }, { "from": 389, "to": 392, "label": "SPLIT 2\nnew knowledge:\nT66 is ground\nT67 is ground\nT72 is ground\nreplacements:X84 -> T72" }, { "from": 391, "to": 393, "label": "CASE" }, { "from": 392, "to": 29, "label": "INSTANCE with matching:\nT1 -> T72\nT2 -> s(T67)\nT3 -> T69" }, { "from": 393, "to": 394, "label": "PARALLEL" }, { "from": 393, "to": 395, "label": "PARALLEL" }, { "from": 394, "to": 396, "label": "EVAL with clause\nminus(X93, 0, X93).\nand substitutionT66 -> T79,\nX93 -> T79,\nT67 -> 0,\nX84 -> T79" }, { "from": 394, "to": 397, "label": "EVAL-BACKTRACK" }, { "from": 395, "to": 399, "label": "EVAL with clause\nminus(s(X102), s(X103), X104) :- minus(X102, X103, X104).\nand substitutionX102 -> T84,\nT66 -> s(T84),\nX103 -> T85,\nT67 -> s(T85),\nX84 -> X105,\nX104 -> X105" }, { "from": 395, "to": 400, "label": "EVAL-BACKTRACK" }, { "from": 396, "to": 398, "label": "SUCCESS" }, { "from": 399, "to": 391, "label": "INSTANCE with matching:\nT66 -> T84\nT67 -> T85\nX84 -> X105" } ], "type": "Graph" } } ---------------------------------------- (165) Complex Obligation (AND) ---------------------------------------- (166) Obligation: Rules: f391_in(T66, T67) -> f393_in(T66, T67) :|: TRUE f393_out(x, x1) -> f391_out(x, x1) :|: TRUE f399_out(T84, T85) -> f395_out(s(T84), s(T85)) :|: TRUE f400_out -> f395_out(x2, x3) :|: TRUE f395_in(x4, x5) -> f400_in :|: TRUE f395_in(s(x6), s(x7)) -> f399_in(x6, x7) :|: TRUE f395_out(x8, x9) -> f393_out(x8, x9) :|: TRUE f393_in(x10, x11) -> f395_in(x10, x11) :|: TRUE f393_in(x12, x13) -> f394_in(x12, x13) :|: TRUE f394_out(x14, x15) -> f393_out(x14, x15) :|: TRUE f399_in(x16, x17) -> f391_in(x16, x17) :|: TRUE f391_out(x18, x19) -> f399_out(x18, x19) :|: TRUE f30_out(T1, T2) -> f29_out(T1, T2) :|: TRUE f29_in(x20, x21) -> f30_in(x20, x21) :|: TRUE f30_in(T10, s(T11)) -> f130_in(T11, T10) :|: TRUE f131_out -> f30_out(x22, x23) :|: TRUE f130_out(x24, x25) -> f30_out(x25, s(x24)) :|: TRUE f30_in(x26, x27) -> f131_in :|: TRUE f162_out(x28, x29) -> f163_in(x30, x29, x28) :|: TRUE f130_in(x31, x32) -> f162_in(x31, x32) :|: TRUE f163_out(x33, x34, x35) -> f130_out(x35, x34) :|: TRUE f163_in(x36, x37, x38) -> f371_in(x36, x37, x38) :|: TRUE f371_out(x39, x40, x41) -> f163_out(x39, x40, x41) :|: TRUE f373_out(x42, x43, x44) -> f371_out(x42, x43, x44) :|: TRUE f371_in(x45, x46, x47) -> f373_in(x45, x46, x47) :|: TRUE f372_out(x48, x49, x50) -> f371_out(x48, x49, x50) :|: TRUE f371_in(x51, x52, x53) -> f372_in(x51, x52, x53) :|: TRUE f389_out(x54, x55) -> f373_out(true, x54, x55) :|: TRUE f390_out -> f373_out(x56, x57, x58) :|: TRUE f373_in(true, x59, x60) -> f389_in(x59, x60) :|: TRUE f373_in(x61, x62, x63) -> f390_in :|: TRUE f391_out(x64, x65) -> f392_in(x66, x65) :|: TRUE f389_in(x67, x68) -> f391_in(x67, x68) :|: TRUE f392_out(x69, x70) -> f389_out(x71, x70) :|: TRUE Start term: f29_in(T1, T2) ---------------------------------------- (167) IRSwTSimpleDependencyGraphProof (EQUIVALENT) Constructed simple dependency graph. Simplified to the following IRSwTs: ---------------------------------------- (168) TRUE ---------------------------------------- (169) Obligation: Rules: f186_out(T24, T25) -> f183_out(T24, T25) :|: TRUE f183_in(x, x1) -> f186_in(x, x1) :|: TRUE f183_out(T42, T43) -> f239_out(T42, T43) :|: TRUE f239_in(x2, x3) -> f183_in(x2, x3) :|: TRUE f200_in(s(x4), s(x5)) -> f239_in(x4, x5) :|: TRUE f239_out(x6, x7) -> f200_out(s(x6), s(x7)) :|: TRUE f250_out -> f200_out(x8, x9) :|: TRUE f200_in(x10, x11) -> f250_in :|: TRUE f186_in(x12, x13) -> f190_in(x12, x13) :|: TRUE f190_out(x14, x15) -> f186_out(x14, x15) :|: TRUE f189_out(x16, x17) -> f186_out(x16, x17) :|: TRUE f186_in(x18, x19) -> f189_in(x18, x19) :|: TRUE f199_out(x20, x21) -> f190_out(x20, x21) :|: TRUE f200_out(x22, x23) -> f190_out(x22, x23) :|: TRUE f190_in(x24, x25) -> f199_in(x24, x25) :|: TRUE f190_in(x26, x27) -> f200_in(x26, x27) :|: TRUE f30_out(T1, T2) -> f29_out(T1, T2) :|: TRUE f29_in(x28, x29) -> f30_in(x28, x29) :|: TRUE f30_in(T10, s(T11)) -> f130_in(T11, T10) :|: TRUE f131_out -> f30_out(x30, x31) :|: TRUE f130_out(x32, x33) -> f30_out(x33, s(x32)) :|: TRUE f30_in(x34, x35) -> f131_in :|: TRUE f162_out(x36, x37) -> f163_in(x38, x37, x36) :|: TRUE f130_in(x39, x40) -> f162_in(x39, x40) :|: TRUE f163_out(x41, x42, x43) -> f130_out(x43, x42) :|: TRUE f162_in(x44, x45) -> f171_in(x44, x45) :|: TRUE f171_out(x46, x47) -> f162_out(x46, x47) :|: TRUE f171_in(x48, x49) -> f172_in(x48, x49) :|: TRUE f172_out(x50, x51) -> f171_out(x50, x51) :|: TRUE f172_in(x52, x53) -> f175_in(x52, x53) :|: TRUE f172_in(x54, x55) -> f176_in(x54, x55) :|: TRUE f175_out(x56, x57) -> f172_out(x56, x57) :|: TRUE f176_out(x58, x59) -> f172_out(x58, x59) :|: TRUE f176_in(x60, s(x61)) -> f183_in(x60, x61) :|: TRUE f184_out -> f176_out(x62, x63) :|: TRUE f183_out(x64, x65) -> f176_out(x64, s(x65)) :|: TRUE f176_in(x66, x67) -> f184_in :|: TRUE Start term: f29_in(T1, T2) ---------------------------------------- (170) IRSwTSimpleDependencyGraphProof (EQUIVALENT) Constructed simple dependency graph. Simplified to the following IRSwTs: intTRSProblem: f183_in(x, x1) -> f186_in(x, x1) :|: TRUE f239_in(x2, x3) -> f183_in(x2, x3) :|: TRUE f200_in(s(x4), s(x5)) -> f239_in(x4, x5) :|: TRUE f186_in(x12, x13) -> f190_in(x12, x13) :|: TRUE f190_in(x26, x27) -> f200_in(x26, x27) :|: TRUE ---------------------------------------- (171) Obligation: Rules: f183_in(x, x1) -> f186_in(x, x1) :|: TRUE f239_in(x2, x3) -> f183_in(x2, x3) :|: TRUE f200_in(s(x4), s(x5)) -> f239_in(x4, x5) :|: TRUE f186_in(x12, x13) -> f190_in(x12, x13) :|: TRUE f190_in(x26, x27) -> f200_in(x26, x27) :|: TRUE ---------------------------------------- (172) IntTRSCompressionProof (EQUIVALENT) Compressed rules. ---------------------------------------- (173) Obligation: Rules: f200_in(s(x4:0), s(x5:0)) -> f200_in(x4:0, x5:0) :|: TRUE ---------------------------------------- (174) IRSFormatTransformerProof (EQUIVALENT) Reformatted IRS to match normalized format (transformed away non-linear left-hand sides, !=, / and %). ---------------------------------------- (175) Obligation: Rules: f200_in(s(x4:0), s(x5:0)) -> f200_in(x4:0, x5:0) :|: TRUE ---------------------------------------- (176) IRSwTTerminationDigraphProof (EQUIVALENT) Constructed termination digraph! Nodes: (1) f200_in(s(x4:0), s(x5:0)) -> f200_in(x4:0, x5:0) :|: TRUE Arcs: (1) -> (1) This digraph is fully evaluated! ---------------------------------------- (177) Obligation: Termination digraph: Nodes: (1) f200_in(s(x4:0), s(x5:0)) -> f200_in(x4:0, x5:0) :|: TRUE Arcs: (1) -> (1) This digraph is fully evaluated! ---------------------------------------- (178) TempFilterProof (SOUND) Used the following sort dictionary for filtering: f200_in(VARIABLE, VARIABLE) s(VARIABLE) Removed predefined arithmetic. ---------------------------------------- (179) Obligation: Rules: f200_in(s(x4:0), s(x5:0)) -> f200_in(x4:0, x5:0) ---------------------------------------- (180) IRSwTToQDPProof (SOUND) Removed the integers and created a QDP-Problem. ---------------------------------------- (181) Obligation: Q DP problem: The TRS P consists of the following rules: f200_in(s(x4:0), s(x5:0)) -> f200_in(x4:0, x5:0) R is empty. Q is empty. We have to consider all (P,Q,R)-chains. ---------------------------------------- (182) 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: *f200_in(s(x4:0), s(x5:0)) -> f200_in(x4:0, x5:0) The graph contains the following edges 1 > 1, 2 > 2 ---------------------------------------- (183) YES ---------------------------------------- (184) Obligation: Rules: f171_in(T11, T10) -> f172_in(T11, T10) :|: TRUE f172_out(x, x1) -> f171_out(x, x1) :|: TRUE f176_in(T24, s(T25)) -> f183_in(T24, T25) :|: TRUE f184_out -> f176_out(x2, x3) :|: TRUE f183_out(x4, x5) -> f176_out(x4, s(x5)) :|: TRUE f176_in(x6, x7) -> f184_in :|: TRUE f162_in(x8, x9) -> f171_in(x8, x9) :|: TRUE f171_out(x10, x11) -> f162_out(x10, x11) :|: TRUE f399_out(T84, T85) -> f395_out(s(T84), s(T85)) :|: TRUE f400_out -> f395_out(T66, T67) :|: TRUE f395_in(x12, x13) -> f400_in :|: TRUE f395_in(s(x14), s(x15)) -> f399_in(x14, x15) :|: TRUE f30_in(x16, s(x17)) -> f130_in(x17, x16) :|: TRUE f131_out -> f30_out(T1, T2) :|: TRUE f130_out(x18, x19) -> f30_out(x19, s(x18)) :|: TRUE f30_in(x20, x21) -> f131_in :|: TRUE f203_out -> f199_out(s(T37), 0) :|: TRUE f199_in(s(x22), 0) -> f203_in :|: TRUE f199_in(x23, x24) -> f205_in :|: TRUE f205_out -> f199_out(x25, x26) :|: TRUE f391_out(x27, x28) -> f392_in(x29, x28) :|: TRUE f389_in(x30, x31) -> f391_in(x30, x31) :|: TRUE f392_out(x32, x33) -> f389_out(x34, x33) :|: TRUE f397_out -> f394_out(x35, x36) :|: TRUE f394_in(x37, x38) -> f397_in :|: TRUE f394_in(T79, 0) -> f396_in :|: TRUE f396_out -> f394_out(x39, 0) :|: TRUE f189_in(x40, x41) -> f195_in :|: TRUE f189_in(0, T32) -> f193_in :|: TRUE f193_out -> f189_out(0, x42) :|: TRUE f195_out -> f189_out(x43, x44) :|: TRUE f178_in -> f178_out :|: TRUE f163_in(x45, x46, x47) -> f371_in(x45, x46, x47) :|: TRUE f371_out(x48, x49, x50) -> f163_out(x48, x49, x50) :|: TRUE f30_out(x51, x52) -> f29_out(x51, x52) :|: TRUE f29_in(x53, x54) -> f30_in(x53, x54) :|: TRUE f200_in(s(T42), s(T43)) -> f239_in(T42, T43) :|: TRUE f239_out(x55, x56) -> f200_out(s(x55), s(x56)) :|: TRUE f250_out -> f200_out(x57, x58) :|: TRUE f200_in(x59, x60) -> f250_in :|: TRUE f186_in(x61, x62) -> f190_in(x61, x62) :|: TRUE f190_out(x63, x64) -> f186_out(x63, x64) :|: TRUE f189_out(x65, x66) -> f186_out(x65, x66) :|: TRUE f186_in(x67, x68) -> f189_in(x67, x68) :|: TRUE f395_out(x69, x70) -> f393_out(x69, x70) :|: TRUE f393_in(x71, x72) -> f395_in(x71, x72) :|: TRUE f393_in(x73, x74) -> f394_in(x73, x74) :|: TRUE f394_out(x75, x76) -> f393_out(x75, x76) :|: TRUE f183_out(x77, x78) -> f239_out(x77, x78) :|: TRUE f239_in(x79, x80) -> f183_in(x79, x80) :|: TRUE f162_out(x81, x82) -> f163_in(x83, x82, x81) :|: TRUE f130_in(x84, x85) -> f162_in(x84, x85) :|: TRUE f163_out(x86, x87, x88) -> f130_out(x88, x87) :|: TRUE f203_in -> f203_out :|: TRUE f373_out(x89, x90, x91) -> f371_out(x89, x90, x91) :|: TRUE f371_in(x92, x93, x94) -> f373_in(x92, x93, x94) :|: TRUE f372_out(x95, x96, x97) -> f371_out(x95, x96, x97) :|: TRUE f371_in(x98, x99, x100) -> f372_in(x98, x99, x100) :|: TRUE f199_out(x101, x102) -> f190_out(x101, x102) :|: TRUE f200_out(x103, x104) -> f190_out(x103, x104) :|: TRUE f190_in(x105, x106) -> f199_in(x105, x106) :|: TRUE f190_in(x107, x108) -> f200_in(x107, x108) :|: TRUE f175_in(T19, 0) -> f178_in :|: TRUE f178_out -> f175_out(x109, 0) :|: TRUE f175_in(x110, x111) -> f179_in :|: TRUE f179_out -> f175_out(x112, x113) :|: TRUE f391_in(x114, x115) -> f393_in(x114, x115) :|: TRUE f393_out(x116, x117) -> f391_out(x116, x117) :|: TRUE f193_in -> f193_out :|: TRUE f172_in(x118, x119) -> f175_in(x118, x119) :|: TRUE f172_in(x120, x121) -> f176_in(x120, x121) :|: TRUE f175_out(x122, x123) -> f172_out(x122, x123) :|: TRUE f176_out(x124, x125) -> f172_out(x124, x125) :|: TRUE f396_in -> f396_out :|: TRUE f186_out(x126, x127) -> f183_out(x126, x127) :|: TRUE f183_in(x128, x129) -> f186_in(x128, x129) :|: TRUE f29_out(x130, s(x131)) -> f392_out(x130, x131) :|: TRUE f392_in(x132, x133) -> f29_in(x132, s(x133)) :|: TRUE f389_out(x134, x135) -> f373_out(true, x134, x135) :|: TRUE f390_out -> f373_out(x136, x137, x138) :|: TRUE f373_in(true, x139, x140) -> f389_in(x139, x140) :|: TRUE f373_in(x141, x142, x143) -> f390_in :|: TRUE f399_in(x144, x145) -> f391_in(x144, x145) :|: TRUE f391_out(x146, x147) -> f399_out(x146, x147) :|: TRUE Start term: f29_in(T1, T2) ---------------------------------------- (185) IRSwTSimpleDependencyGraphProof (EQUIVALENT) Constructed simple dependency graph. Simplified to the following IRSwTs: intTRSProblem: f171_in(T11, T10) -> f172_in(T11, T10) :|: TRUE f172_out(x, x1) -> f171_out(x, x1) :|: TRUE f176_in(T24, s(T25)) -> f183_in(T24, T25) :|: TRUE f183_out(x4, x5) -> f176_out(x4, s(x5)) :|: TRUE f162_in(x8, x9) -> f171_in(x8, x9) :|: TRUE f171_out(x10, x11) -> f162_out(x10, x11) :|: TRUE f399_out(T84, T85) -> f395_out(s(T84), s(T85)) :|: TRUE f395_in(s(x14), s(x15)) -> f399_in(x14, x15) :|: TRUE f30_in(x16, s(x17)) -> f130_in(x17, x16) :|: TRUE f203_out -> f199_out(s(T37), 0) :|: TRUE f199_in(s(x22), 0) -> f203_in :|: TRUE f391_out(x27, x28) -> f392_in(x29, x28) :|: TRUE f389_in(x30, x31) -> f391_in(x30, x31) :|: TRUE f394_in(T79, 0) -> f396_in :|: TRUE f396_out -> f394_out(x39, 0) :|: TRUE f189_in(0, T32) -> f193_in :|: TRUE f193_out -> f189_out(0, x42) :|: TRUE f178_in -> f178_out :|: TRUE f163_in(x45, x46, x47) -> f371_in(x45, x46, x47) :|: TRUE f29_in(x53, x54) -> f30_in(x53, x54) :|: TRUE f200_in(s(T42), s(T43)) -> f239_in(T42, T43) :|: TRUE f239_out(x55, x56) -> f200_out(s(x55), s(x56)) :|: TRUE f186_in(x61, x62) -> f190_in(x61, x62) :|: TRUE f190_out(x63, x64) -> f186_out(x63, x64) :|: TRUE f189_out(x65, x66) -> f186_out(x65, x66) :|: TRUE f186_in(x67, x68) -> f189_in(x67, x68) :|: TRUE f395_out(x69, x70) -> f393_out(x69, x70) :|: TRUE f393_in(x71, x72) -> f395_in(x71, x72) :|: TRUE f393_in(x73, x74) -> f394_in(x73, x74) :|: TRUE f394_out(x75, x76) -> f393_out(x75, x76) :|: TRUE f183_out(x77, x78) -> f239_out(x77, x78) :|: TRUE f239_in(x79, x80) -> f183_in(x79, x80) :|: TRUE f162_out(x81, x82) -> f163_in(x83, x82, x81) :|: TRUE f130_in(x84, x85) -> f162_in(x84, x85) :|: TRUE f203_in -> f203_out :|: TRUE f371_in(x92, x93, x94) -> f373_in(x92, x93, x94) :|: TRUE f199_out(x101, x102) -> f190_out(x101, x102) :|: TRUE f200_out(x103, x104) -> f190_out(x103, x104) :|: TRUE f190_in(x105, x106) -> f199_in(x105, x106) :|: TRUE f190_in(x107, x108) -> f200_in(x107, x108) :|: TRUE f175_in(T19, 0) -> f178_in :|: TRUE f178_out -> f175_out(x109, 0) :|: TRUE f391_in(x114, x115) -> f393_in(x114, x115) :|: TRUE f393_out(x116, x117) -> f391_out(x116, x117) :|: TRUE f193_in -> f193_out :|: TRUE f172_in(x118, x119) -> f175_in(x118, x119) :|: TRUE f172_in(x120, x121) -> f176_in(x120, x121) :|: TRUE f175_out(x122, x123) -> f172_out(x122, x123) :|: TRUE f176_out(x124, x125) -> f172_out(x124, x125) :|: TRUE f396_in -> f396_out :|: TRUE f186_out(x126, x127) -> f183_out(x126, x127) :|: TRUE f183_in(x128, x129) -> f186_in(x128, x129) :|: TRUE f392_in(x132, x133) -> f29_in(x132, s(x133)) :|: TRUE f373_in(true, x139, x140) -> f389_in(x139, x140) :|: TRUE f399_in(x144, x145) -> f391_in(x144, x145) :|: TRUE f391_out(x146, x147) -> f399_out(x146, x147) :|: TRUE ---------------------------------------- (186) Obligation: Rules: f171_in(T11, T10) -> f172_in(T11, T10) :|: TRUE f172_out(x, x1) -> f171_out(x, x1) :|: TRUE f176_in(T24, s(T25)) -> f183_in(T24, T25) :|: TRUE f183_out(x4, x5) -> f176_out(x4, s(x5)) :|: TRUE f162_in(x8, x9) -> f171_in(x8, x9) :|: TRUE f171_out(x10, x11) -> f162_out(x10, x11) :|: TRUE f399_out(T84, T85) -> f395_out(s(T84), s(T85)) :|: TRUE f395_in(s(x14), s(x15)) -> f399_in(x14, x15) :|: TRUE f30_in(x16, s(x17)) -> f130_in(x17, x16) :|: TRUE f203_out -> f199_out(s(T37), 0) :|: TRUE f199_in(s(x22), 0) -> f203_in :|: TRUE f391_out(x27, x28) -> f392_in(x29, x28) :|: TRUE f389_in(x30, x31) -> f391_in(x30, x31) :|: TRUE f394_in(T79, 0) -> f396_in :|: TRUE f396_out -> f394_out(x39, 0) :|: TRUE f189_in(0, T32) -> f193_in :|: TRUE f193_out -> f189_out(0, x42) :|: TRUE f178_in -> f178_out :|: TRUE f163_in(x45, x46, x47) -> f371_in(x45, x46, x47) :|: TRUE f29_in(x53, x54) -> f30_in(x53, x54) :|: TRUE f200_in(s(T42), s(T43)) -> f239_in(T42, T43) :|: TRUE f239_out(x55, x56) -> f200_out(s(x55), s(x56)) :|: TRUE f186_in(x61, x62) -> f190_in(x61, x62) :|: TRUE f190_out(x63, x64) -> f186_out(x63, x64) :|: TRUE f189_out(x65, x66) -> f186_out(x65, x66) :|: TRUE f186_in(x67, x68) -> f189_in(x67, x68) :|: TRUE f395_out(x69, x70) -> f393_out(x69, x70) :|: TRUE f393_in(x71, x72) -> f395_in(x71, x72) :|: TRUE f393_in(x73, x74) -> f394_in(x73, x74) :|: TRUE f394_out(x75, x76) -> f393_out(x75, x76) :|: TRUE f183_out(x77, x78) -> f239_out(x77, x78) :|: TRUE f239_in(x79, x80) -> f183_in(x79, x80) :|: TRUE f162_out(x81, x82) -> f163_in(x83, x82, x81) :|: TRUE f130_in(x84, x85) -> f162_in(x84, x85) :|: TRUE f203_in -> f203_out :|: TRUE f371_in(x92, x93, x94) -> f373_in(x92, x93, x94) :|: TRUE f199_out(x101, x102) -> f190_out(x101, x102) :|: TRUE f200_out(x103, x104) -> f190_out(x103, x104) :|: TRUE f190_in(x105, x106) -> f199_in(x105, x106) :|: TRUE f190_in(x107, x108) -> f200_in(x107, x108) :|: TRUE f175_in(T19, 0) -> f178_in :|: TRUE f178_out -> f175_out(x109, 0) :|: TRUE f391_in(x114, x115) -> f393_in(x114, x115) :|: TRUE f393_out(x116, x117) -> f391_out(x116, x117) :|: TRUE f193_in -> f193_out :|: TRUE f172_in(x118, x119) -> f175_in(x118, x119) :|: TRUE f172_in(x120, x121) -> f176_in(x120, x121) :|: TRUE f175_out(x122, x123) -> f172_out(x122, x123) :|: TRUE f176_out(x124, x125) -> f172_out(x124, x125) :|: TRUE f396_in -> f396_out :|: TRUE f186_out(x126, x127) -> f183_out(x126, x127) :|: TRUE f183_in(x128, x129) -> f186_in(x128, x129) :|: TRUE f392_in(x132, x133) -> f29_in(x132, s(x133)) :|: TRUE f373_in(true, x139, x140) -> f389_in(x139, x140) :|: TRUE f399_in(x144, x145) -> f391_in(x144, x145) :|: TRUE f391_out(x146, x147) -> f399_out(x146, x147) :|: TRUE ---------------------------------------- (187) IntTRSCompressionProof (EQUIVALENT) Compressed rules. ---------------------------------------- (188) Obligation: Rules: f183_out(x4:0, x5:0) -> f393_in(s(x5:0), x4:0) :|: TRUE f186_in(s(x22:0), cons_0) -> f183_out(s(T37:0), 0) :|: TRUE && cons_0 = 0 f391_out(x27:0, x28:0) -> f186_in(x28:0, T25:0) :|: TRUE f391_out(x146:0, x147:0) -> f391_out(s(x146:0), s(x147:0)) :|: TRUE f393_in(s(x14:0), s(x15:0)) -> f393_in(x14:0, x15:0) :|: TRUE f186_in(x, x1) -> f183_out(0, x2) :|: TRUE && x = 0 f393_in(x3, x4) -> f391_out(x5, 0) :|: TRUE && x4 = 0 f186_in(s(T42:0), s(T43:0)) -> f186_in(T42:0, T43:0) :|: TRUE f391_out(x6, x7) -> f393_in(0, x8) :|: TRUE f183_out(x77:0, x78:0) -> f183_out(s(x77:0), s(x78:0)) :|: TRUE ---------------------------------------- (189) IRSFormatTransformerProof (EQUIVALENT) Reformatted IRS to match normalized format (transformed away non-linear left-hand sides, !=, / and %). ---------------------------------------- (190) Obligation: Rules: f183_out(x4:0, x5:0) -> f393_in(s(x5:0), x4:0) :|: TRUE f186_in(s(x22:0), cons_0) -> f183_out(s(T37:0), 0) :|: TRUE && cons_0 = 0 f391_out(x27:0, x28:0) -> f186_in(x28:0, T25:0) :|: TRUE f391_out(x146:0, x147:0) -> f391_out(s(x146:0), s(x147:0)) :|: TRUE f393_in(s(x14:0), s(x15:0)) -> f393_in(x14:0, x15:0) :|: TRUE f186_in(x, x1) -> f183_out(0, x2) :|: TRUE && x = 0 f393_in(x3, x4) -> f391_out(x5, 0) :|: TRUE && x4 = 0 f186_in(s(T42:0), s(T43:0)) -> f186_in(T42:0, T43:0) :|: TRUE f391_out(x6, x7) -> f393_in(0, x8) :|: TRUE f183_out(x77:0, x78:0) -> f183_out(s(x77:0), s(x78:0)) :|: TRUE ---------------------------------------- (191) IRSwTTerminationDigraphProof (EQUIVALENT) Constructed termination digraph! Nodes: (1) f183_out(x4:0, x5:0) -> f393_in(s(x5:0), x4:0) :|: TRUE (2) f186_in(s(x22:0), cons_0) -> f183_out(s(T37:0), 0) :|: TRUE && cons_0 = 0 (3) f391_out(x27:0, x28:0) -> f186_in(x28:0, T25:0) :|: TRUE (4) f391_out(x146:0, x147:0) -> f391_out(s(x146:0), s(x147:0)) :|: TRUE (5) f393_in(s(x14:0), s(x15:0)) -> f393_in(x14:0, x15:0) :|: TRUE (6) f186_in(x, x1) -> f183_out(0, x2) :|: TRUE && x = 0 (7) f393_in(x3, x4) -> f391_out(x5, 0) :|: TRUE && x4 = 0 (8) f186_in(s(T42:0), s(T43:0)) -> f186_in(T42:0, T43:0) :|: TRUE (9) f391_out(x6, x7) -> f393_in(0, x8) :|: TRUE (10) f183_out(x77:0, x78:0) -> f183_out(s(x77:0), s(x78:0)) :|: TRUE Arcs: (1) -> (5), (7) (2) -> (1), (10) (3) -> (2), (6), (8) (4) -> (3), (4), (9) (5) -> (5), (7) (6) -> (1), (10) (7) -> (3), (4), (9) (8) -> (2), (6), (8) (9) -> (7) (10) -> (1), (10) This digraph is fully evaluated! ---------------------------------------- (192) Obligation: Termination digraph: Nodes: (1) f183_out(x4:0, x5:0) -> f393_in(s(x5:0), x4:0) :|: TRUE (2) f183_out(x77:0, x78:0) -> f183_out(s(x77:0), s(x78:0)) :|: TRUE (3) f186_in(x, x1) -> f183_out(0, x2) :|: TRUE && x = 0 (4) f186_in(s(x22:0), cons_0) -> f183_out(s(T37:0), 0) :|: TRUE && cons_0 = 0 (5) f186_in(s(T42:0), s(T43:0)) -> f186_in(T42:0, T43:0) :|: TRUE (6) f391_out(x27:0, x28:0) -> f186_in(x28:0, T25:0) :|: TRUE (7) f391_out(x146:0, x147:0) -> f391_out(s(x146:0), s(x147:0)) :|: TRUE (8) f393_in(x3, x4) -> f391_out(x5, 0) :|: TRUE && x4 = 0 (9) f391_out(x6, x7) -> f393_in(0, x8) :|: TRUE (10) f393_in(s(x14:0), s(x15:0)) -> f393_in(x14:0, x15:0) :|: TRUE Arcs: (1) -> (8), (10) (2) -> (1), (2) (3) -> (1), (2) (4) -> (1), (2) (5) -> (3), (4), (5) (6) -> (3), (4), (5) (7) -> (6), (7), (9) (8) -> (6), (7), (9) (9) -> (8) (10) -> (8), (10) This digraph is fully evaluated! ---------------------------------------- (193) IntTRSCompressionProof (EQUIVALENT) Compressed rules. ---------------------------------------- (194) Obligation: Rules: f183_out(x77:0:0, x78:0:0) -> f183_out(s(x77:0:0), s(x78:0:0)) :|: TRUE f391_out(x6:0, x7:0) -> f393_in(0, x8:0) :|: TRUE f186_in(s(x22:0:0), cons_0) -> f183_out(s(T37:0:0), 0) :|: TRUE && cons_0 = 0 f186_in(x, x1) -> f183_out(0, x2) :|: TRUE && x = 0 f186_in(s(T42:0:0), s(T43:0:0)) -> f186_in(T42:0:0, T43:0:0) :|: TRUE f391_out(x27:0:0, x28:0:0) -> f186_in(x28:0:0, T25:0:0) :|: TRUE f391_out(x146:0:0, x147:0:0) -> f391_out(s(x146:0:0), s(x147:0:0)) :|: TRUE f393_in(s(x14:0:0), s(x15:0:0)) -> f393_in(x14:0:0, x15:0:0) :|: TRUE f393_in(x3, x4) -> f391_out(x5, 0) :|: TRUE && x4 = 0 f183_out(x4:0:0, x5:0:0) -> f393_in(s(x5:0:0), x4:0:0) :|: TRUE ---------------------------------------- (195) IntTRSUnneededArgumentFilterProof (EQUIVALENT) Some arguments are removed because they cannot influence termination. We removed arguments according to the following replacements: f391_out(x1, x2) -> f391_out(x2) ---------------------------------------- (196) Obligation: Rules: f183_out(x77:0:0, x78:0:0) -> f183_out(s(x77:0:0), s(x78:0:0)) :|: TRUE f391_out(x7:0) -> f393_in(0, x8:0) :|: TRUE f186_in(s(x22:0:0), cons_0) -> f183_out(s(T37:0:0), 0) :|: TRUE && cons_0 = 0 f186_in(x, x1) -> f183_out(0, x2) :|: TRUE && x = 0 f186_in(s(T42:0:0), s(T43:0:0)) -> f186_in(T42:0:0, T43:0:0) :|: TRUE f391_out(x28:0:0) -> f186_in(x28:0:0, T25:0:0) :|: TRUE f391_out(x147:0:0) -> f391_out(s(x147:0:0)) :|: TRUE f393_in(s(x14:0:0), s(x15:0:0)) -> f393_in(x14:0:0, x15:0:0) :|: TRUE f393_in(x3, x4) -> f391_out(0) :|: TRUE && x4 = 0 f183_out(x4:0:0, x5:0:0) -> f393_in(s(x5:0:0), x4:0:0) :|: TRUE ---------------------------------------- (197) IRSwTToIntTRSProof (SOUND) Applied path-length measure to transform intTRS with terms to intTRS. ---------------------------------------- (198) Obligation: Rules: f183_out(x, x1) -> f183_out(s(x), s(x1)) :|: TRUE f391_out(x2) -> f393_in(0, x3) :|: TRUE f186_in(s(x4), cons_0) -> f183_out(s(x6), 0) :|: TRUE && cons_0 = 0 f186_in(x5, x7) -> f183_out(0, x18) :|: TRUE && x5 = 0 f186_in(s(x10), s(x11)) -> f186_in(x10, x11) :|: TRUE f391_out(x12) -> f186_in(x12, x13) :|: TRUE f391_out(x14) -> f391_out(s(x14)) :|: TRUE f393_in(s(x15), s(x16)) -> f393_in(x15, x16) :|: TRUE f393_in(x21, x22) -> f391_out(0) :|: TRUE && x22 = 0 f183_out(x19, x20) -> f393_in(s(x20), x19) :|: TRUE ---------------------------------------- (199) IntTRSCompressionProof (EQUIVALENT) Compressed rules. ---------------------------------------- (200) Obligation: Rules: f183_out(x:0, x1:0) -> f183_out(s(x:0), s(x1:0)) :|: TRUE f391_out(x2:0) -> f393_in(0, x3:0) :|: TRUE f186_in(s(x4:0), cons_0) -> f183_out(s(x6:0), 0) :|: TRUE && cons_0 = 0 f186_in(x, x1) -> f183_out(0, x2) :|: TRUE && x = 0 f186_in(s(x10:0), s(x11:0)) -> f186_in(x10:0, x11:0) :|: TRUE f391_out(x14:0) -> f391_out(s(x14:0)) :|: TRUE f393_in(s(x15:0), s(x16:0)) -> f393_in(x15:0, x16:0) :|: TRUE f391_out(x12:0) -> f186_in(x12:0, x13:0) :|: TRUE f183_out(x19:0, x20:0) -> f393_in(s(x20:0), x19:0) :|: TRUE f393_in(x3, x4) -> f391_out(0) :|: TRUE && x4 = 0 ---------------------------------------- (201) PrologToDTProblemTransformerProof (SOUND) Built DT problem from termination graph DT10. { "root": 10, "program": { "directives": [], "clauses": [ [ "(le (0) Y (true))", null ], [ "(le (s X) (0) (false))", null ], [ "(le (s X) (s Y) B)", "(le X Y B)" ], [ "(minus X (0) X)", null ], [ "(minus (s X) (s Y) Z)", "(minus X Y Z)" ], [ "(div X (s Y) Z)", "(',' (le (s Y) X B) (if B X (s Y) Z))" ], [ "(if (false) X (s Y) (0))", null ], [ "(if (true) X (s Y) (s Z))", "(',' (minus X Y U) (div U (s Y) Z))" ] ] }, "graph": { "nodes": { "type": "Nodes", "352": { "goal": [{ "clause": -1, "scope": -1, "term": "(le T27 T28 X42)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T27", "T28" ], "free": ["X42"], "exprvars": [] } }, "155": { "goal": [{ "clause": -1, "scope": -1, "term": "(',' (le (s T8) T7 X7) (if X7 T7 (s T8) T10))" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T7", "T8" ], "free": ["X7"], "exprvars": [] } }, "430": { "goal": [{ "clause": 3, "scope": 6, "term": "(minus (s T72) T73 X95)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T72", "T73" ], "free": ["X95"], "exprvars": [] } }, "354": { "goal": [{ "clause": -1, "scope": -1, "term": "(if T31 (s T28) (s T27) T10)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T27", "T28", "T31" ], "free": [], "exprvars": [] } }, "431": { "goal": [{ "clause": 4, "scope": 6, "term": "(minus (s T72) T73 X95)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T72", "T73" ], "free": ["X95"], "exprvars": [] } }, "432": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "356": { "goal": [ { "clause": 0, "scope": 4, "term": "(le T27 T28 X42)" }, { "clause": 1, "scope": 4, "term": "(le T27 T28 X42)" }, { "clause": 2, "scope": 4, "term": "(le T27 T28 X42)" } ], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T27", "T28" ], "free": ["X42"], "exprvars": [] } }, "433": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "357": { "goal": [{ "clause": 0, "scope": 4, "term": "(le T27 T28 X42)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T27", "T28" ], "free": ["X42"], "exprvars": [] } }, "434": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "358": { "goal": [ { "clause": 1, "scope": 4, "term": "(le T27 T28 X42)" }, { "clause": 2, "scope": 4, "term": "(le T27 T28 X42)" } ], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T27", "T28" ], "free": ["X42"], "exprvars": [] } }, "435": { "goal": [{ "clause": -1, "scope": -1, "term": "(minus T90 T91 X116)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T90", "T91" ], "free": ["X116"], "exprvars": [] } }, "359": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "436": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "437": { "goal": [ { "clause": 3, "scope": 7, "term": "(minus T90 T91 X116)" }, { "clause": 4, "scope": 7, "term": "(minus T90 T91 X116)" } ], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T90", "T91" ], "free": ["X116"], "exprvars": [] } }, "438": { "goal": [{ "clause": 3, "scope": 7, "term": "(minus T90 T91 X116)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T90", "T91" ], "free": ["X116"], "exprvars": [] } }, "439": { "goal": [{ "clause": 4, "scope": 7, "term": "(minus T90 T91 X116)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T90", "T91" ], "free": ["X116"], "exprvars": [] } }, "10": { "goal": [{ "clause": -1, "scope": -1, "term": "(div T1 T2 T3)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T1", "T2" ], "free": [], "exprvars": [] } }, "360": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "361": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "164": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "362": { "goal": [{ "clause": 1, "scope": 4, "term": "(le T27 T28 X42)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T27", "T28" ], "free": ["X42"], "exprvars": [] } }, "363": { "goal": [{ "clause": 2, "scope": 4, "term": "(le T27 T28 X42)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T27", "T28" ], "free": ["X42"], "exprvars": [] } }, "440": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "166": { "goal": [ { "clause": 0, "scope": 2, "term": "(',' (le (s T8) T7 X7) (if X7 T7 (s T8) T10))" }, { "clause": 1, "scope": 2, "term": "(',' (le (s T8) T7 X7) (if X7 T7 (s T8) T10))" }, { "clause": 2, "scope": 2, "term": "(',' (le (s T8) T7 X7) (if X7 T7 (s T8) T10))" } ], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T7", "T8" ], "free": ["X7"], "exprvars": [] } }, "364": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "441": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "321": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "365": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "442": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "168": { "goal": [ { "clause": 1, "scope": 2, "term": "(',' (le (s T8) T7 X7) (if X7 T7 (s T8) T10))" }, { "clause": 2, "scope": 2, "term": "(',' (le (s T8) T7 X7) (if X7 T7 (s T8) T10))" } ], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T7", "T8" ], "free": ["X7"], "exprvars": [] } }, "366": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "443": { "goal": [{ "clause": -1, "scope": -1, "term": "(minus T103 T104 X135)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T103", "T104" ], "free": ["X135"], "exprvars": [] } }, "367": { "goal": [{ "clause": -1, "scope": -1, "term": "(le T48 T49 X68)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T48", "T49" ], "free": ["X68"], "exprvars": [] } }, "444": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "368": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "401": { "goal": [ { "clause": 6, "scope": 5, "term": "(if T31 (s T28) (s T27) T10)" }, { "clause": 7, "scope": 5, "term": "(if T31 (s T28) (s T27) T10)" } ], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T27", "T28", "T31" ], "free": [], "exprvars": [] } }, "325": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "326": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "207": { "goal": [{ "clause": 1, "scope": 2, "term": "(',' (le (s T8) T7 X7) (if X7 T7 (s T8) T10))" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T7", "T8" ], "free": ["X7"], "exprvars": [] } }, "328": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "208": { "goal": [{ "clause": 2, "scope": 2, "term": "(',' (le (s T8) T7 X7) (if X7 T7 (s T8) T10))" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T7", "T8" ], "free": ["X7"], "exprvars": [] } }, "26": { "goal": [{ "clause": 5, "scope": 1, "term": "(div T1 T2 T3)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T1", "T2" ], "free": [], "exprvars": [] } }, "290": { "goal": [{ "clause": 6, "scope": 3, "term": "(if (false) (0) (s T15) T10)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": ["T15"], "free": [], "exprvars": [] } }, "295": { "goal": [{ "clause": 7, "scope": 3, "term": "(if (false) (0) (s T15) T10)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": ["T15"], "free": [], "exprvars": [] } }, "215": { "goal": [{ "clause": -1, "scope": -1, "term": "(if (false) (0) (s T15) T10)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": ["T15"], "free": [], "exprvars": [] } }, "260": { "goal": [ { "clause": 6, "scope": 3, "term": "(if (false) (0) (s T15) T10)" }, { "clause": 7, "scope": 3, "term": "(if (false) (0) (s T15) T10)" } ], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": ["T15"], "free": [], "exprvars": [] } }, "340": { "goal": [{ "clause": -1, "scope": -1, "term": "(',' (le T27 T28 X42) (if X42 (s T28) (s T27) T10))" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T27", "T28" ], "free": ["X42"], "exprvars": [] } }, "343": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "420": { "goal": [{ "clause": 6, "scope": 5, "term": "(if T31 (s T28) (s T27) T10)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T27", "T28", "T31" ], "free": [], "exprvars": [] } }, "421": { "goal": [{ "clause": 7, "scope": 5, "term": "(if T31 (s T28) (s T27) T10)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T27", "T28", "T31" ], "free": [], "exprvars": [] } }, "224": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "422": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "423": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "424": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "425": { "goal": [{ "clause": -1, "scope": -1, "term": "(',' (minus (s T72) T73 X95) (div X95 (s T73) T75))" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T72", "T73" ], "free": ["X95"], "exprvars": [] } }, "426": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "427": { "goal": [{ "clause": -1, "scope": -1, "term": "(minus (s T72) T73 X95)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T72", "T73" ], "free": ["X95"], "exprvars": [] } }, "428": { "goal": [{ "clause": -1, "scope": -1, "term": "(div T78 (s T73) T75)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T73", "T78" ], "free": [], "exprvars": [] } }, "429": { "goal": [ { "clause": 3, "scope": 6, "term": "(minus (s T72) T73 X95)" }, { "clause": 4, "scope": 6, "term": "(minus (s T72) T73 X95)" } ], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T72", "T73" ], "free": ["X95"], "exprvars": [] } } }, "edges": [ { "from": 10, "to": 26, "label": "CASE" }, { "from": 26, "to": 155, "label": "EVAL with clause\ndiv(X4, s(X5), X6) :- ','(le(s(X5), X4, X7), if(X7, X4, s(X5), X6)).\nand substitutionT1 -> T7,\nX4 -> T7,\nX5 -> T8,\nT2 -> s(T8),\nT3 -> T10,\nX6 -> T10,\nT9 -> T10" }, { "from": 26, "to": 164, "label": "EVAL-BACKTRACK" }, { "from": 155, "to": 166, "label": "CASE" }, { "from": 166, "to": 168, "label": "BACKTRACK\nfor clause: le(0, Y, true)because of non-unification" }, { "from": 168, "to": 207, "label": "PARALLEL" }, { "from": 168, "to": 208, "label": "PARALLEL" }, { "from": 207, "to": 215, "label": "EVAL with clause\nle(s(X13), 0, false).\nand substitutionT8 -> T15,\nX13 -> T15,\nT7 -> 0,\nX7 -> false" }, { "from": 207, "to": 224, "label": "EVAL-BACKTRACK" }, { "from": 208, "to": 340, "label": "EVAL with clause\nle(s(X39), s(X40), X41) :- le(X39, X40, X41).\nand substitutionT8 -> T27,\nX39 -> T27,\nX40 -> T28,\nT7 -> s(T28),\nX7 -> X42,\nX41 -> X42" }, { "from": 208, "to": 343, "label": "EVAL-BACKTRACK" }, { "from": 215, "to": 260, "label": "CASE" }, { "from": 260, "to": 290, "label": "PARALLEL" }, { "from": 260, "to": 295, "label": "PARALLEL" }, { "from": 290, "to": 321, "label": "EVAL with clause\nif(false, X26, s(X27), 0).\nand substitutionX26 -> 0,\nT15 -> T22,\nX27 -> T22,\nT10 -> 0" }, { "from": 290, "to": 325, "label": "EVAL-BACKTRACK" }, { "from": 295, "to": 328, "label": "BACKTRACK\nfor clause: if(true, X, s(Y), s(Z)) :- ','(minus(X, Y, U), div(U, s(Y), Z))because of non-unification" }, { "from": 321, "to": 326, "label": "SUCCESS" }, { "from": 340, "to": 352, "label": "SPLIT 1" }, { "from": 340, "to": 354, "label": "SPLIT 2\nnew knowledge:\nT27 is ground\nT28 is ground\nT31 is ground\nreplacements:X42 -> T31" }, { "from": 352, "to": 356, "label": "CASE" }, { "from": 354, "to": 401, "label": "CASE" }, { "from": 356, "to": 357, "label": "PARALLEL" }, { "from": 356, "to": 358, "label": "PARALLEL" }, { "from": 357, "to": 359, "label": "EVAL with clause\nle(0, X51, true).\nand substitutionT27 -> 0,\nT28 -> T38,\nX51 -> T38,\nX42 -> true" }, { "from": 357, "to": 360, "label": "EVAL-BACKTRACK" }, { "from": 358, "to": 362, "label": "PARALLEL" }, { "from": 358, "to": 363, "label": "PARALLEL" }, { "from": 359, "to": 361, "label": "SUCCESS" }, { "from": 362, "to": 364, "label": "EVAL with clause\nle(s(X56), 0, false).\nand substitutionX56 -> T43,\nT27 -> s(T43),\nT28 -> 0,\nX42 -> false" }, { "from": 362, "to": 365, "label": "EVAL-BACKTRACK" }, { "from": 363, "to": 367, "label": "EVAL with clause\nle(s(X65), s(X66), X67) :- le(X65, X66, X67).\nand substitutionX65 -> T48,\nT27 -> s(T48),\nX66 -> T49,\nT28 -> s(T49),\nX42 -> X68,\nX67 -> X68" }, { "from": 363, "to": 368, "label": "EVAL-BACKTRACK" }, { "from": 364, "to": 366, "label": "SUCCESS" }, { "from": 367, "to": 352, "label": "INSTANCE with matching:\nT27 -> T48\nT28 -> T49\nX42 -> X68" }, { "from": 401, "to": 420, "label": "PARALLEL" }, { "from": 401, "to": 421, "label": "PARALLEL" }, { "from": 420, "to": 422, "label": "EVAL with clause\nif(false, X83, s(X84), 0).\nand substitutionT31 -> false,\nT28 -> T64,\nX83 -> s(T64),\nT27 -> T65,\nX84 -> T65,\nT10 -> 0" }, { "from": 420, "to": 423, "label": "EVAL-BACKTRACK" }, { "from": 421, "to": 425, "label": "EVAL with clause\nif(true, X92, s(X93), s(X94)) :- ','(minus(X92, X93, X95), div(X95, s(X93), X94)).\nand substitutionT31 -> true,\nT28 -> T72,\nX92 -> s(T72),\nT27 -> T73,\nX93 -> T73,\nX94 -> T75,\nT10 -> s(T75),\nT74 -> T75" }, { "from": 421, "to": 426, "label": "EVAL-BACKTRACK" }, { "from": 422, "to": 424, "label": "SUCCESS" }, { "from": 425, "to": 427, "label": "SPLIT 1" }, { "from": 425, "to": 428, "label": "SPLIT 2\nnew knowledge:\nT72 is ground\nT73 is ground\nT78 is ground\nreplacements:X95 -> T78" }, { "from": 427, "to": 429, "label": "CASE" }, { "from": 428, "to": 10, "label": "INSTANCE with matching:\nT1 -> T78\nT2 -> s(T73)\nT3 -> T75" }, { "from": 429, "to": 430, "label": "PARALLEL" }, { "from": 429, "to": 431, "label": "PARALLEL" }, { "from": 430, "to": 432, "label": "EVAL with clause\nminus(X104, 0, X104).\nand substitutionT72 -> T85,\nX104 -> s(T85),\nT73 -> 0,\nX95 -> s(T85)" }, { "from": 430, "to": 433, "label": "EVAL-BACKTRACK" }, { "from": 431, "to": 435, "label": "EVAL with clause\nminus(s(X113), s(X114), X115) :- minus(X113, X114, X115).\nand substitutionT72 -> T90,\nX113 -> T90,\nX114 -> T91,\nT73 -> s(T91),\nX95 -> X116,\nX115 -> X116" }, { "from": 431, "to": 436, "label": "EVAL-BACKTRACK" }, { "from": 432, "to": 434, "label": "SUCCESS" }, { "from": 435, "to": 437, "label": "CASE" }, { "from": 437, "to": 438, "label": "PARALLEL" }, { "from": 437, "to": 439, "label": "PARALLEL" }, { "from": 438, "to": 440, "label": "EVAL with clause\nminus(X123, 0, X123).\nand substitutionT90 -> T98,\nX123 -> T98,\nT91 -> 0,\nX116 -> T98" }, { "from": 438, "to": 441, "label": "EVAL-BACKTRACK" }, { "from": 439, "to": 443, "label": "EVAL with clause\nminus(s(X132), s(X133), X134) :- minus(X132, X133, X134).\nand substitutionX132 -> T103,\nT90 -> s(T103),\nX133 -> T104,\nT91 -> s(T104),\nX116 -> X135,\nX134 -> X135" }, { "from": 439, "to": 444, "label": "EVAL-BACKTRACK" }, { "from": 440, "to": 442, "label": "SUCCESS" }, { "from": 443, "to": 435, "label": "INSTANCE with matching:\nT90 -> T103\nT91 -> T104\nX116 -> X135" } ], "type": "Graph" } } ---------------------------------------- (202) Obligation: Triples: leA(s(X1), s(X2), X3) :- leA(X1, X2, X3). minusD(s(X1), s(X2), X3) :- minusD(X1, X2, X3). divB(s(X1), s(X2), X3) :- leA(X2, X1, X4). divB(s(X1), s(s(X2)), s(X3)) :- ','(lecA(s(X2), X1, true), minusD(X1, X2, X4)). divB(s(X1), s(X2), s(X3)) :- ','(lecA(X2, X1, true), ','(minuscC(X1, X2, X4), divB(X4, s(X2), X3))). Clauses: lecA(0, X1, true). lecA(s(X1), 0, false). lecA(s(X1), s(X2), X3) :- lecA(X1, X2, X3). divcB(0, s(X1), 0). divcB(s(X1), s(X2), 0) :- lecA(X2, X1, false). divcB(s(X1), s(X2), s(X3)) :- ','(lecA(X2, X1, true), ','(minuscC(X1, X2, X4), divcB(X4, s(X2), X3))). minuscD(X1, 0, X1). minuscD(s(X1), s(X2), X3) :- minuscD(X1, X2, X3). minuscC(X1, 0, s(X1)). minuscC(X1, s(X2), X3) :- minuscD(X1, X2, X3). Afs: divB(x1, x2, x3) = divB(x1, x2) ---------------------------------------- (203) TriplesToPiDPProof (SOUND) We use the technique of [DT09]. With regard to the inferred argument filtering the predicates were used in the following modes: divB_in_3: (b,b,f) leA_in_3: (b,b,f) lecA_in_3: (b,b,b) minusD_in_3: (b,b,f) minuscC_in_3: (b,b,f) minuscD_in_3: (b,b,f) Transforming TRIPLES into the following Term Rewriting System: Pi DP problem: The TRS P consists of the following rules: DIVB_IN_GGA(s(X1), s(X2), X3) -> U3_GGA(X1, X2, X3, leA_in_gga(X2, X1, X4)) DIVB_IN_GGA(s(X1), s(X2), X3) -> LEA_IN_GGA(X2, X1, X4) LEA_IN_GGA(s(X1), s(X2), X3) -> U1_GGA(X1, X2, X3, leA_in_gga(X1, X2, X3)) LEA_IN_GGA(s(X1), s(X2), X3) -> LEA_IN_GGA(X1, X2, X3) DIVB_IN_GGA(s(X1), s(s(X2)), s(X3)) -> U4_GGA(X1, X2, X3, lecA_in_ggg(s(X2), X1, true)) U4_GGA(X1, X2, X3, lecA_out_ggg(s(X2), X1, true)) -> U5_GGA(X1, X2, X3, minusD_in_gga(X1, X2, X4)) U4_GGA(X1, X2, X3, lecA_out_ggg(s(X2), X1, true)) -> MINUSD_IN_GGA(X1, X2, X4) MINUSD_IN_GGA(s(X1), s(X2), X3) -> U2_GGA(X1, X2, X3, minusD_in_gga(X1, X2, X3)) MINUSD_IN_GGA(s(X1), s(X2), X3) -> MINUSD_IN_GGA(X1, X2, X3) DIVB_IN_GGA(s(X1), s(X2), s(X3)) -> U6_GGA(X1, X2, X3, lecA_in_ggg(X2, X1, true)) U6_GGA(X1, X2, X3, lecA_out_ggg(X2, X1, true)) -> U7_GGA(X1, X2, X3, minuscC_in_gga(X1, X2, X4)) U7_GGA(X1, X2, X3, minuscC_out_gga(X1, X2, X4)) -> U8_GGA(X1, X2, X3, divB_in_gga(X4, s(X2), X3)) U7_GGA(X1, X2, X3, minuscC_out_gga(X1, X2, X4)) -> DIVB_IN_GGA(X4, s(X2), X3) The TRS R consists of the following rules: lecA_in_ggg(0, X1, true) -> lecA_out_ggg(0, X1, true) lecA_in_ggg(s(X1), 0, false) -> lecA_out_ggg(s(X1), 0, false) lecA_in_ggg(s(X1), s(X2), X3) -> U10_ggg(X1, X2, X3, lecA_in_ggg(X1, X2, X3)) U10_ggg(X1, X2, X3, lecA_out_ggg(X1, X2, X3)) -> lecA_out_ggg(s(X1), s(X2), X3) minuscC_in_gga(X1, 0, s(X1)) -> minuscC_out_gga(X1, 0, s(X1)) minuscC_in_gga(X1, s(X2), X3) -> U16_gga(X1, X2, X3, minuscD_in_gga(X1, X2, X3)) minuscD_in_gga(X1, 0, X1) -> minuscD_out_gga(X1, 0, X1) minuscD_in_gga(s(X1), s(X2), X3) -> U15_gga(X1, X2, X3, minuscD_in_gga(X1, X2, X3)) U15_gga(X1, X2, X3, minuscD_out_gga(X1, X2, X3)) -> minuscD_out_gga(s(X1), s(X2), X3) U16_gga(X1, X2, X3, minuscD_out_gga(X1, X2, X3)) -> minuscC_out_gga(X1, s(X2), X3) The argument filtering Pi contains the following mapping: divB_in_gga(x1, x2, x3) = divB_in_gga(x1, x2) s(x1) = s(x1) leA_in_gga(x1, x2, x3) = leA_in_gga(x1, x2) lecA_in_ggg(x1, x2, x3) = lecA_in_ggg(x1, x2, x3) 0 = 0 true = true lecA_out_ggg(x1, x2, x3) = lecA_out_ggg(x1, x2, x3) false = false U10_ggg(x1, x2, x3, x4) = U10_ggg(x1, x2, x3, x4) minusD_in_gga(x1, x2, x3) = minusD_in_gga(x1, x2) minuscC_in_gga(x1, x2, x3) = minuscC_in_gga(x1, x2) minuscC_out_gga(x1, x2, x3) = minuscC_out_gga(x1, x2, x3) U16_gga(x1, x2, x3, x4) = U16_gga(x1, x2, x4) minuscD_in_gga(x1, x2, x3) = minuscD_in_gga(x1, x2) minuscD_out_gga(x1, x2, x3) = minuscD_out_gga(x1, x2, x3) U15_gga(x1, x2, x3, x4) = U15_gga(x1, x2, x4) DIVB_IN_GGA(x1, x2, x3) = DIVB_IN_GGA(x1, x2) U3_GGA(x1, x2, x3, x4) = U3_GGA(x1, x2, x4) LEA_IN_GGA(x1, x2, x3) = LEA_IN_GGA(x1, x2) U1_GGA(x1, x2, x3, x4) = U1_GGA(x1, x2, x4) U4_GGA(x1, x2, x3, x4) = U4_GGA(x1, x2, x4) U5_GGA(x1, x2, x3, x4) = U5_GGA(x1, x2, x4) MINUSD_IN_GGA(x1, x2, x3) = MINUSD_IN_GGA(x1, x2) U2_GGA(x1, x2, x3, x4) = U2_GGA(x1, x2, x4) U6_GGA(x1, x2, x3, x4) = U6_GGA(x1, x2, x4) U7_GGA(x1, x2, x3, x4) = U7_GGA(x1, x2, x4) U8_GGA(x1, x2, x3, x4) = U8_GGA(x1, x2, x4) We have to consider all (P,R,Pi)-chains Infinitary Constructor Rewriting Termination of PiDP implies Termination of TRIPLES ---------------------------------------- (204) Obligation: Pi DP problem: The TRS P consists of the following rules: DIVB_IN_GGA(s(X1), s(X2), X3) -> U3_GGA(X1, X2, X3, leA_in_gga(X2, X1, X4)) DIVB_IN_GGA(s(X1), s(X2), X3) -> LEA_IN_GGA(X2, X1, X4) LEA_IN_GGA(s(X1), s(X2), X3) -> U1_GGA(X1, X2, X3, leA_in_gga(X1, X2, X3)) LEA_IN_GGA(s(X1), s(X2), X3) -> LEA_IN_GGA(X1, X2, X3) DIVB_IN_GGA(s(X1), s(s(X2)), s(X3)) -> U4_GGA(X1, X2, X3, lecA_in_ggg(s(X2), X1, true)) U4_GGA(X1, X2, X3, lecA_out_ggg(s(X2), X1, true)) -> U5_GGA(X1, X2, X3, minusD_in_gga(X1, X2, X4)) U4_GGA(X1, X2, X3, lecA_out_ggg(s(X2), X1, true)) -> MINUSD_IN_GGA(X1, X2, X4) MINUSD_IN_GGA(s(X1), s(X2), X3) -> U2_GGA(X1, X2, X3, minusD_in_gga(X1, X2, X3)) MINUSD_IN_GGA(s(X1), s(X2), X3) -> MINUSD_IN_GGA(X1, X2, X3) DIVB_IN_GGA(s(X1), s(X2), s(X3)) -> U6_GGA(X1, X2, X3, lecA_in_ggg(X2, X1, true)) U6_GGA(X1, X2, X3, lecA_out_ggg(X2, X1, true)) -> U7_GGA(X1, X2, X3, minuscC_in_gga(X1, X2, X4)) U7_GGA(X1, X2, X3, minuscC_out_gga(X1, X2, X4)) -> U8_GGA(X1, X2, X3, divB_in_gga(X4, s(X2), X3)) U7_GGA(X1, X2, X3, minuscC_out_gga(X1, X2, X4)) -> DIVB_IN_GGA(X4, s(X2), X3) The TRS R consists of the following rules: lecA_in_ggg(0, X1, true) -> lecA_out_ggg(0, X1, true) lecA_in_ggg(s(X1), 0, false) -> lecA_out_ggg(s(X1), 0, false) lecA_in_ggg(s(X1), s(X2), X3) -> U10_ggg(X1, X2, X3, lecA_in_ggg(X1, X2, X3)) U10_ggg(X1, X2, X3, lecA_out_ggg(X1, X2, X3)) -> lecA_out_ggg(s(X1), s(X2), X3) minuscC_in_gga(X1, 0, s(X1)) -> minuscC_out_gga(X1, 0, s(X1)) minuscC_in_gga(X1, s(X2), X3) -> U16_gga(X1, X2, X3, minuscD_in_gga(X1, X2, X3)) minuscD_in_gga(X1, 0, X1) -> minuscD_out_gga(X1, 0, X1) minuscD_in_gga(s(X1), s(X2), X3) -> U15_gga(X1, X2, X3, minuscD_in_gga(X1, X2, X3)) U15_gga(X1, X2, X3, minuscD_out_gga(X1, X2, X3)) -> minuscD_out_gga(s(X1), s(X2), X3) U16_gga(X1, X2, X3, minuscD_out_gga(X1, X2, X3)) -> minuscC_out_gga(X1, s(X2), X3) The argument filtering Pi contains the following mapping: divB_in_gga(x1, x2, x3) = divB_in_gga(x1, x2) s(x1) = s(x1) leA_in_gga(x1, x2, x3) = leA_in_gga(x1, x2) lecA_in_ggg(x1, x2, x3) = lecA_in_ggg(x1, x2, x3) 0 = 0 true = true lecA_out_ggg(x1, x2, x3) = lecA_out_ggg(x1, x2, x3) false = false U10_ggg(x1, x2, x3, x4) = U10_ggg(x1, x2, x3, x4) minusD_in_gga(x1, x2, x3) = minusD_in_gga(x1, x2) minuscC_in_gga(x1, x2, x3) = minuscC_in_gga(x1, x2) minuscC_out_gga(x1, x2, x3) = minuscC_out_gga(x1, x2, x3) U16_gga(x1, x2, x3, x4) = U16_gga(x1, x2, x4) minuscD_in_gga(x1, x2, x3) = minuscD_in_gga(x1, x2) minuscD_out_gga(x1, x2, x3) = minuscD_out_gga(x1, x2, x3) U15_gga(x1, x2, x3, x4) = U15_gga(x1, x2, x4) DIVB_IN_GGA(x1, x2, x3) = DIVB_IN_GGA(x1, x2) U3_GGA(x1, x2, x3, x4) = U3_GGA(x1, x2, x4) LEA_IN_GGA(x1, x2, x3) = LEA_IN_GGA(x1, x2) U1_GGA(x1, x2, x3, x4) = U1_GGA(x1, x2, x4) U4_GGA(x1, x2, x3, x4) = U4_GGA(x1, x2, x4) U5_GGA(x1, x2, x3, x4) = U5_GGA(x1, x2, x4) MINUSD_IN_GGA(x1, x2, x3) = MINUSD_IN_GGA(x1, x2) U2_GGA(x1, x2, x3, x4) = U2_GGA(x1, x2, x4) U6_GGA(x1, x2, x3, x4) = U6_GGA(x1, x2, x4) U7_GGA(x1, x2, x3, x4) = U7_GGA(x1, x2, x4) U8_GGA(x1, x2, x3, x4) = U8_GGA(x1, x2, x4) We have to consider all (P,R,Pi)-chains ---------------------------------------- (205) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LOPSTR] contains 3 SCCs with 8 less nodes. ---------------------------------------- (206) Complex Obligation (AND) ---------------------------------------- (207) Obligation: Pi DP problem: The TRS P consists of the following rules: MINUSD_IN_GGA(s(X1), s(X2), X3) -> MINUSD_IN_GGA(X1, X2, X3) The TRS R consists of the following rules: lecA_in_ggg(0, X1, true) -> lecA_out_ggg(0, X1, true) lecA_in_ggg(s(X1), 0, false) -> lecA_out_ggg(s(X1), 0, false) lecA_in_ggg(s(X1), s(X2), X3) -> U10_ggg(X1, X2, X3, lecA_in_ggg(X1, X2, X3)) U10_ggg(X1, X2, X3, lecA_out_ggg(X1, X2, X3)) -> lecA_out_ggg(s(X1), s(X2), X3) minuscC_in_gga(X1, 0, s(X1)) -> minuscC_out_gga(X1, 0, s(X1)) minuscC_in_gga(X1, s(X2), X3) -> U16_gga(X1, X2, X3, minuscD_in_gga(X1, X2, X3)) minuscD_in_gga(X1, 0, X1) -> minuscD_out_gga(X1, 0, X1) minuscD_in_gga(s(X1), s(X2), X3) -> U15_gga(X1, X2, X3, minuscD_in_gga(X1, X2, X3)) U15_gga(X1, X2, X3, minuscD_out_gga(X1, X2, X3)) -> minuscD_out_gga(s(X1), s(X2), X3) U16_gga(X1, X2, X3, minuscD_out_gga(X1, X2, X3)) -> minuscC_out_gga(X1, s(X2), X3) The argument filtering Pi contains the following mapping: s(x1) = s(x1) lecA_in_ggg(x1, x2, x3) = lecA_in_ggg(x1, x2, x3) 0 = 0 true = true lecA_out_ggg(x1, x2, x3) = lecA_out_ggg(x1, x2, x3) false = false U10_ggg(x1, x2, x3, x4) = U10_ggg(x1, x2, x3, x4) minuscC_in_gga(x1, x2, x3) = minuscC_in_gga(x1, x2) minuscC_out_gga(x1, x2, x3) = minuscC_out_gga(x1, x2, x3) U16_gga(x1, x2, x3, x4) = U16_gga(x1, x2, x4) minuscD_in_gga(x1, x2, x3) = minuscD_in_gga(x1, x2) minuscD_out_gga(x1, x2, x3) = minuscD_out_gga(x1, x2, x3) U15_gga(x1, x2, x3, x4) = U15_gga(x1, x2, x4) MINUSD_IN_GGA(x1, x2, x3) = MINUSD_IN_GGA(x1, x2) We have to consider all (P,R,Pi)-chains ---------------------------------------- (208) UsableRulesProof (EQUIVALENT) For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R. ---------------------------------------- (209) Obligation: Pi DP problem: The TRS P consists of the following rules: MINUSD_IN_GGA(s(X1), s(X2), X3) -> MINUSD_IN_GGA(X1, X2, X3) R is empty. The argument filtering Pi contains the following mapping: s(x1) = s(x1) MINUSD_IN_GGA(x1, x2, x3) = MINUSD_IN_GGA(x1, x2) We have to consider all (P,R,Pi)-chains ---------------------------------------- (210) PiDPToQDPProof (SOUND) Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi. ---------------------------------------- (211) Obligation: Q DP problem: The TRS P consists of the following rules: MINUSD_IN_GGA(s(X1), s(X2)) -> MINUSD_IN_GGA(X1, X2) R is empty. Q is empty. We have to consider all (P,Q,R)-chains. ---------------------------------------- (212) 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: *MINUSD_IN_GGA(s(X1), s(X2)) -> MINUSD_IN_GGA(X1, X2) The graph contains the following edges 1 > 1, 2 > 2 ---------------------------------------- (213) YES ---------------------------------------- (214) Obligation: Pi DP problem: The TRS P consists of the following rules: LEA_IN_GGA(s(X1), s(X2), X3) -> LEA_IN_GGA(X1, X2, X3) The TRS R consists of the following rules: lecA_in_ggg(0, X1, true) -> lecA_out_ggg(0, X1, true) lecA_in_ggg(s(X1), 0, false) -> lecA_out_ggg(s(X1), 0, false) lecA_in_ggg(s(X1), s(X2), X3) -> U10_ggg(X1, X2, X3, lecA_in_ggg(X1, X2, X3)) U10_ggg(X1, X2, X3, lecA_out_ggg(X1, X2, X3)) -> lecA_out_ggg(s(X1), s(X2), X3) minuscC_in_gga(X1, 0, s(X1)) -> minuscC_out_gga(X1, 0, s(X1)) minuscC_in_gga(X1, s(X2), X3) -> U16_gga(X1, X2, X3, minuscD_in_gga(X1, X2, X3)) minuscD_in_gga(X1, 0, X1) -> minuscD_out_gga(X1, 0, X1) minuscD_in_gga(s(X1), s(X2), X3) -> U15_gga(X1, X2, X3, minuscD_in_gga(X1, X2, X3)) U15_gga(X1, X2, X3, minuscD_out_gga(X1, X2, X3)) -> minuscD_out_gga(s(X1), s(X2), X3) U16_gga(X1, X2, X3, minuscD_out_gga(X1, X2, X3)) -> minuscC_out_gga(X1, s(X2), X3) The argument filtering Pi contains the following mapping: s(x1) = s(x1) lecA_in_ggg(x1, x2, x3) = lecA_in_ggg(x1, x2, x3) 0 = 0 true = true lecA_out_ggg(x1, x2, x3) = lecA_out_ggg(x1, x2, x3) false = false U10_ggg(x1, x2, x3, x4) = U10_ggg(x1, x2, x3, x4) minuscC_in_gga(x1, x2, x3) = minuscC_in_gga(x1, x2) minuscC_out_gga(x1, x2, x3) = minuscC_out_gga(x1, x2, x3) U16_gga(x1, x2, x3, x4) = U16_gga(x1, x2, x4) minuscD_in_gga(x1, x2, x3) = minuscD_in_gga(x1, x2) minuscD_out_gga(x1, x2, x3) = minuscD_out_gga(x1, x2, x3) U15_gga(x1, x2, x3, x4) = U15_gga(x1, x2, x4) LEA_IN_GGA(x1, x2, x3) = LEA_IN_GGA(x1, x2) We have to consider all (P,R,Pi)-chains ---------------------------------------- (215) UsableRulesProof (EQUIVALENT) For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R. ---------------------------------------- (216) Obligation: Pi DP problem: The TRS P consists of the following rules: LEA_IN_GGA(s(X1), s(X2), X3) -> LEA_IN_GGA(X1, X2, X3) R is empty. The argument filtering Pi contains the following mapping: s(x1) = s(x1) LEA_IN_GGA(x1, x2, x3) = LEA_IN_GGA(x1, x2) We have to consider all (P,R,Pi)-chains ---------------------------------------- (217) PiDPToQDPProof (SOUND) Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi. ---------------------------------------- (218) Obligation: Q DP problem: The TRS P consists of the following rules: LEA_IN_GGA(s(X1), s(X2)) -> LEA_IN_GGA(X1, X2) R is empty. Q is empty. We have to consider all (P,Q,R)-chains. ---------------------------------------- (219) 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: *LEA_IN_GGA(s(X1), s(X2)) -> LEA_IN_GGA(X1, X2) The graph contains the following edges 1 > 1, 2 > 2 ---------------------------------------- (220) YES ---------------------------------------- (221) Obligation: Pi DP problem: The TRS P consists of the following rules: DIVB_IN_GGA(s(X1), s(X2), s(X3)) -> U6_GGA(X1, X2, X3, lecA_in_ggg(X2, X1, true)) U6_GGA(X1, X2, X3, lecA_out_ggg(X2, X1, true)) -> U7_GGA(X1, X2, X3, minuscC_in_gga(X1, X2, X4)) U7_GGA(X1, X2, X3, minuscC_out_gga(X1, X2, X4)) -> DIVB_IN_GGA(X4, s(X2), X3) The TRS R consists of the following rules: lecA_in_ggg(0, X1, true) -> lecA_out_ggg(0, X1, true) lecA_in_ggg(s(X1), 0, false) -> lecA_out_ggg(s(X1), 0, false) lecA_in_ggg(s(X1), s(X2), X3) -> U10_ggg(X1, X2, X3, lecA_in_ggg(X1, X2, X3)) U10_ggg(X1, X2, X3, lecA_out_ggg(X1, X2, X3)) -> lecA_out_ggg(s(X1), s(X2), X3) minuscC_in_gga(X1, 0, s(X1)) -> minuscC_out_gga(X1, 0, s(X1)) minuscC_in_gga(X1, s(X2), X3) -> U16_gga(X1, X2, X3, minuscD_in_gga(X1, X2, X3)) minuscD_in_gga(X1, 0, X1) -> minuscD_out_gga(X1, 0, X1) minuscD_in_gga(s(X1), s(X2), X3) -> U15_gga(X1, X2, X3, minuscD_in_gga(X1, X2, X3)) U15_gga(X1, X2, X3, minuscD_out_gga(X1, X2, X3)) -> minuscD_out_gga(s(X1), s(X2), X3) U16_gga(X1, X2, X3, minuscD_out_gga(X1, X2, X3)) -> minuscC_out_gga(X1, s(X2), X3) The argument filtering Pi contains the following mapping: s(x1) = s(x1) lecA_in_ggg(x1, x2, x3) = lecA_in_ggg(x1, x2, x3) 0 = 0 true = true lecA_out_ggg(x1, x2, x3) = lecA_out_ggg(x1, x2, x3) false = false U10_ggg(x1, x2, x3, x4) = U10_ggg(x1, x2, x3, x4) minuscC_in_gga(x1, x2, x3) = minuscC_in_gga(x1, x2) minuscC_out_gga(x1, x2, x3) = minuscC_out_gga(x1, x2, x3) U16_gga(x1, x2, x3, x4) = U16_gga(x1, x2, x4) minuscD_in_gga(x1, x2, x3) = minuscD_in_gga(x1, x2) minuscD_out_gga(x1, x2, x3) = minuscD_out_gga(x1, x2, x3) U15_gga(x1, x2, x3, x4) = U15_gga(x1, x2, x4) DIVB_IN_GGA(x1, x2, x3) = DIVB_IN_GGA(x1, x2) U6_GGA(x1, x2, x3, x4) = U6_GGA(x1, x2, x4) U7_GGA(x1, x2, x3, x4) = U7_GGA(x1, x2, x4) We have to consider all (P,R,Pi)-chains ---------------------------------------- (222) PiDPToQDPProof (SOUND) Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi. ---------------------------------------- (223) Obligation: Q DP problem: The TRS P consists of the following rules: DIVB_IN_GGA(s(X1), s(X2)) -> U6_GGA(X1, X2, lecA_in_ggg(X2, X1, true)) U6_GGA(X1, X2, lecA_out_ggg(X2, X1, true)) -> U7_GGA(X1, X2, minuscC_in_gga(X1, X2)) U7_GGA(X1, X2, minuscC_out_gga(X1, X2, X4)) -> DIVB_IN_GGA(X4, s(X2)) The TRS R consists of the following rules: lecA_in_ggg(0, X1, true) -> lecA_out_ggg(0, X1, true) lecA_in_ggg(s(X1), 0, false) -> lecA_out_ggg(s(X1), 0, false) lecA_in_ggg(s(X1), s(X2), X3) -> U10_ggg(X1, X2, X3, lecA_in_ggg(X1, X2, X3)) U10_ggg(X1, X2, X3, lecA_out_ggg(X1, X2, X3)) -> lecA_out_ggg(s(X1), s(X2), X3) minuscC_in_gga(X1, 0) -> minuscC_out_gga(X1, 0, s(X1)) minuscC_in_gga(X1, s(X2)) -> U16_gga(X1, X2, minuscD_in_gga(X1, X2)) minuscD_in_gga(X1, 0) -> minuscD_out_gga(X1, 0, X1) minuscD_in_gga(s(X1), s(X2)) -> U15_gga(X1, X2, minuscD_in_gga(X1, X2)) U15_gga(X1, X2, minuscD_out_gga(X1, X2, X3)) -> minuscD_out_gga(s(X1), s(X2), X3) U16_gga(X1, X2, minuscD_out_gga(X1, X2, X3)) -> minuscC_out_gga(X1, s(X2), X3) The set Q consists of the following terms: lecA_in_ggg(x0, x1, x2) U10_ggg(x0, x1, x2, x3) minuscC_in_gga(x0, x1) minuscD_in_gga(x0, x1) U15_gga(x0, x1, x2) U16_gga(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (224) QDPQMonotonicMRRProof (EQUIVALENT) By using the Q-monotonic rule removal processor with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented such that it always occurs at a strongly monotonic position in a (P,Q,R)-chain. Strictly oriented rules of the TRS R: lecA_in_ggg(s(X1), 0, false) -> lecA_out_ggg(s(X1), 0, false) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(DIVB_IN_GGA(x_1, x_2)) = 0 POL(U10_ggg(x_1, x_2, x_3, x_4)) = x_4 POL(U15_gga(x_1, x_2, x_3)) = 0 POL(U16_gga(x_1, x_2, x_3)) = 1 POL(U6_GGA(x_1, x_2, x_3)) = 2*x_3 POL(U7_GGA(x_1, x_2, x_3)) = 0 POL(false) = 1 POL(lecA_in_ggg(x_1, x_2, x_3)) = 2*x_3 POL(lecA_out_ggg(x_1, x_2, x_3)) = 0 POL(minuscC_in_gga(x_1, x_2)) = 2 POL(minuscC_out_gga(x_1, x_2, x_3)) = 0 POL(minuscD_in_gga(x_1, x_2)) = 0 POL(minuscD_out_gga(x_1, x_2, x_3)) = 0 POL(s(x_1)) = 0 POL(true) = 0 ---------------------------------------- (225) Obligation: Q DP problem: The TRS P consists of the following rules: DIVB_IN_GGA(s(X1), s(X2)) -> U6_GGA(X1, X2, lecA_in_ggg(X2, X1, true)) U6_GGA(X1, X2, lecA_out_ggg(X2, X1, true)) -> U7_GGA(X1, X2, minuscC_in_gga(X1, X2)) U7_GGA(X1, X2, minuscC_out_gga(X1, X2, X4)) -> DIVB_IN_GGA(X4, s(X2)) The TRS R consists of the following rules: lecA_in_ggg(0, X1, true) -> lecA_out_ggg(0, X1, true) lecA_in_ggg(s(X1), s(X2), X3) -> U10_ggg(X1, X2, X3, lecA_in_ggg(X1, X2, X3)) U10_ggg(X1, X2, X3, lecA_out_ggg(X1, X2, X3)) -> lecA_out_ggg(s(X1), s(X2), X3) minuscC_in_gga(X1, 0) -> minuscC_out_gga(X1, 0, s(X1)) minuscC_in_gga(X1, s(X2)) -> U16_gga(X1, X2, minuscD_in_gga(X1, X2)) minuscD_in_gga(X1, 0) -> minuscD_out_gga(X1, 0, X1) minuscD_in_gga(s(X1), s(X2)) -> U15_gga(X1, X2, minuscD_in_gga(X1, X2)) U15_gga(X1, X2, minuscD_out_gga(X1, X2, X3)) -> minuscD_out_gga(s(X1), s(X2), X3) U16_gga(X1, X2, minuscD_out_gga(X1, X2, X3)) -> minuscC_out_gga(X1, s(X2), X3) The set Q consists of the following terms: lecA_in_ggg(x0, x1, x2) U10_ggg(x0, x1, x2, x3) minuscC_in_gga(x0, x1) minuscD_in_gga(x0, x1) U15_gga(x0, x1, x2) U16_gga(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (226) QDPQMonotonicMRRProof (EQUIVALENT) By using the Q-monotonic rule removal processor with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented such that it always occurs at a strongly monotonic position in a (P,Q,R)-chain. Strictly oriented rules of the TRS R: minuscC_in_gga(X1, s(X2)) -> U16_gga(X1, X2, minuscD_in_gga(X1, X2)) minuscD_in_gga(s(X1), s(X2)) -> U15_gga(X1, X2, minuscD_in_gga(X1, X2)) Used ordering: Polynomial interpretation [POLO]: POL(0) = 0 POL(DIVB_IN_GGA(x_1, x_2)) = 2*x_1 POL(U10_ggg(x_1, x_2, x_3, x_4)) = 0 POL(U15_gga(x_1, x_2, x_3)) = x_3 POL(U16_gga(x_1, x_2, x_3)) = x_3 POL(U6_GGA(x_1, x_2, x_3)) = 2 + 2*x_1 POL(U7_GGA(x_1, x_2, x_3)) = 2*x_3 POL(lecA_in_ggg(x_1, x_2, x_3)) = 0 POL(lecA_out_ggg(x_1, x_2, x_3)) = 0 POL(minuscC_in_gga(x_1, x_2)) = 1 + x_1 POL(minuscC_out_gga(x_1, x_2, x_3)) = x_3 POL(minuscD_in_gga(x_1, x_2)) = x_1 POL(minuscD_out_gga(x_1, x_2, x_3)) = x_3 POL(s(x_1)) = 1 + x_1 POL(true) = 0 ---------------------------------------- (227) Obligation: Q DP problem: The TRS P consists of the following rules: DIVB_IN_GGA(s(X1), s(X2)) -> U6_GGA(X1, X2, lecA_in_ggg(X2, X1, true)) U6_GGA(X1, X2, lecA_out_ggg(X2, X1, true)) -> U7_GGA(X1, X2, minuscC_in_gga(X1, X2)) U7_GGA(X1, X2, minuscC_out_gga(X1, X2, X4)) -> DIVB_IN_GGA(X4, s(X2)) The TRS R consists of the following rules: lecA_in_ggg(0, X1, true) -> lecA_out_ggg(0, X1, true) lecA_in_ggg(s(X1), s(X2), X3) -> U10_ggg(X1, X2, X3, lecA_in_ggg(X1, X2, X3)) U10_ggg(X1, X2, X3, lecA_out_ggg(X1, X2, X3)) -> lecA_out_ggg(s(X1), s(X2), X3) minuscC_in_gga(X1, 0) -> minuscC_out_gga(X1, 0, s(X1)) minuscD_in_gga(X1, 0) -> minuscD_out_gga(X1, 0, X1) U15_gga(X1, X2, minuscD_out_gga(X1, X2, X3)) -> minuscD_out_gga(s(X1), s(X2), X3) U16_gga(X1, X2, minuscD_out_gga(X1, X2, X3)) -> minuscC_out_gga(X1, s(X2), X3) The set Q consists of the following terms: lecA_in_ggg(x0, x1, x2) U10_ggg(x0, x1, x2, x3) minuscC_in_gga(x0, x1) minuscD_in_gga(x0, x1) U15_gga(x0, x1, x2) U16_gga(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (228) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (229) Obligation: Q DP problem: The TRS P consists of the following rules: DIVB_IN_GGA(s(X1), s(X2)) -> U6_GGA(X1, X2, lecA_in_ggg(X2, X1, true)) U6_GGA(X1, X2, lecA_out_ggg(X2, X1, true)) -> U7_GGA(X1, X2, minuscC_in_gga(X1, X2)) U7_GGA(X1, X2, minuscC_out_gga(X1, X2, X4)) -> DIVB_IN_GGA(X4, s(X2)) The TRS R consists of the following rules: minuscC_in_gga(X1, 0) -> minuscC_out_gga(X1, 0, s(X1)) lecA_in_ggg(0, X1, true) -> lecA_out_ggg(0, X1, true) lecA_in_ggg(s(X1), s(X2), X3) -> U10_ggg(X1, X2, X3, lecA_in_ggg(X1, X2, X3)) U10_ggg(X1, X2, X3, lecA_out_ggg(X1, X2, X3)) -> lecA_out_ggg(s(X1), s(X2), X3) The set Q consists of the following terms: lecA_in_ggg(x0, x1, x2) U10_ggg(x0, x1, x2, x3) minuscC_in_gga(x0, x1) minuscD_in_gga(x0, x1) U15_gga(x0, x1, x2) U16_gga(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (230) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. minuscD_in_gga(x0, x1) U15_gga(x0, x1, x2) U16_gga(x0, x1, x2) ---------------------------------------- (231) Obligation: Q DP problem: The TRS P consists of the following rules: DIVB_IN_GGA(s(X1), s(X2)) -> U6_GGA(X1, X2, lecA_in_ggg(X2, X1, true)) U6_GGA(X1, X2, lecA_out_ggg(X2, X1, true)) -> U7_GGA(X1, X2, minuscC_in_gga(X1, X2)) U7_GGA(X1, X2, minuscC_out_gga(X1, X2, X4)) -> DIVB_IN_GGA(X4, s(X2)) The TRS R consists of the following rules: minuscC_in_gga(X1, 0) -> minuscC_out_gga(X1, 0, s(X1)) lecA_in_ggg(0, X1, true) -> lecA_out_ggg(0, X1, true) lecA_in_ggg(s(X1), s(X2), X3) -> U10_ggg(X1, X2, X3, lecA_in_ggg(X1, X2, X3)) U10_ggg(X1, X2, X3, lecA_out_ggg(X1, X2, X3)) -> lecA_out_ggg(s(X1), s(X2), X3) The set Q consists of the following terms: lecA_in_ggg(x0, x1, x2) U10_ggg(x0, x1, x2, x3) minuscC_in_gga(x0, x1) We have to consider all (P,Q,R)-chains. ---------------------------------------- (232) TransformationProof (SOUND) By narrowing [LPAR04] the rule U6_GGA(X1, X2, lecA_out_ggg(X2, X1, true)) -> U7_GGA(X1, X2, minuscC_in_gga(X1, X2)) at position [2] we obtained the following new rules [LPAR04]: (U6_GGA(x0, 0, lecA_out_ggg(0, x0, true)) -> U7_GGA(x0, 0, minuscC_out_gga(x0, 0, s(x0))),U6_GGA(x0, 0, lecA_out_ggg(0, x0, true)) -> U7_GGA(x0, 0, minuscC_out_gga(x0, 0, s(x0)))) ---------------------------------------- (233) Obligation: Q DP problem: The TRS P consists of the following rules: DIVB_IN_GGA(s(X1), s(X2)) -> U6_GGA(X1, X2, lecA_in_ggg(X2, X1, true)) U7_GGA(X1, X2, minuscC_out_gga(X1, X2, X4)) -> DIVB_IN_GGA(X4, s(X2)) U6_GGA(x0, 0, lecA_out_ggg(0, x0, true)) -> U7_GGA(x0, 0, minuscC_out_gga(x0, 0, s(x0))) The TRS R consists of the following rules: minuscC_in_gga(X1, 0) -> minuscC_out_gga(X1, 0, s(X1)) lecA_in_ggg(0, X1, true) -> lecA_out_ggg(0, X1, true) lecA_in_ggg(s(X1), s(X2), X3) -> U10_ggg(X1, X2, X3, lecA_in_ggg(X1, X2, X3)) U10_ggg(X1, X2, X3, lecA_out_ggg(X1, X2, X3)) -> lecA_out_ggg(s(X1), s(X2), X3) The set Q consists of the following terms: lecA_in_ggg(x0, x1, x2) U10_ggg(x0, x1, x2, x3) minuscC_in_gga(x0, x1) We have to consider all (P,Q,R)-chains. ---------------------------------------- (234) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (235) Obligation: Q DP problem: The TRS P consists of the following rules: DIVB_IN_GGA(s(X1), s(X2)) -> U6_GGA(X1, X2, lecA_in_ggg(X2, X1, true)) U7_GGA(X1, X2, minuscC_out_gga(X1, X2, X4)) -> DIVB_IN_GGA(X4, s(X2)) U6_GGA(x0, 0, lecA_out_ggg(0, x0, true)) -> U7_GGA(x0, 0, minuscC_out_gga(x0, 0, s(x0))) The TRS R consists of the following rules: lecA_in_ggg(0, X1, true) -> lecA_out_ggg(0, X1, true) lecA_in_ggg(s(X1), s(X2), X3) -> U10_ggg(X1, X2, X3, lecA_in_ggg(X1, X2, X3)) U10_ggg(X1, X2, X3, lecA_out_ggg(X1, X2, X3)) -> lecA_out_ggg(s(X1), s(X2), X3) The set Q consists of the following terms: lecA_in_ggg(x0, x1, x2) U10_ggg(x0, x1, x2, x3) minuscC_in_gga(x0, x1) We have to consider all (P,Q,R)-chains. ---------------------------------------- (236) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. minuscC_in_gga(x0, x1) ---------------------------------------- (237) Obligation: Q DP problem: The TRS P consists of the following rules: DIVB_IN_GGA(s(X1), s(X2)) -> U6_GGA(X1, X2, lecA_in_ggg(X2, X1, true)) U7_GGA(X1, X2, minuscC_out_gga(X1, X2, X4)) -> DIVB_IN_GGA(X4, s(X2)) U6_GGA(x0, 0, lecA_out_ggg(0, x0, true)) -> U7_GGA(x0, 0, minuscC_out_gga(x0, 0, s(x0))) The TRS R consists of the following rules: lecA_in_ggg(0, X1, true) -> lecA_out_ggg(0, X1, true) lecA_in_ggg(s(X1), s(X2), X3) -> U10_ggg(X1, X2, X3, lecA_in_ggg(X1, X2, X3)) U10_ggg(X1, X2, X3, lecA_out_ggg(X1, X2, X3)) -> lecA_out_ggg(s(X1), s(X2), X3) The set Q consists of the following terms: lecA_in_ggg(x0, x1, x2) U10_ggg(x0, x1, x2, x3) We have to consider all (P,Q,R)-chains. ---------------------------------------- (238) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule U7_GGA(X1, X2, minuscC_out_gga(X1, X2, X4)) -> DIVB_IN_GGA(X4, s(X2)) we obtained the following new rules [LPAR04]: (U7_GGA(z0, 0, minuscC_out_gga(z0, 0, s(z0))) -> DIVB_IN_GGA(s(z0), s(0)),U7_GGA(z0, 0, minuscC_out_gga(z0, 0, s(z0))) -> DIVB_IN_GGA(s(z0), s(0))) ---------------------------------------- (239) Obligation: Q DP problem: The TRS P consists of the following rules: DIVB_IN_GGA(s(X1), s(X2)) -> U6_GGA(X1, X2, lecA_in_ggg(X2, X1, true)) U6_GGA(x0, 0, lecA_out_ggg(0, x0, true)) -> U7_GGA(x0, 0, minuscC_out_gga(x0, 0, s(x0))) U7_GGA(z0, 0, minuscC_out_gga(z0, 0, s(z0))) -> DIVB_IN_GGA(s(z0), s(0)) The TRS R consists of the following rules: lecA_in_ggg(0, X1, true) -> lecA_out_ggg(0, X1, true) lecA_in_ggg(s(X1), s(X2), X3) -> U10_ggg(X1, X2, X3, lecA_in_ggg(X1, X2, X3)) U10_ggg(X1, X2, X3, lecA_out_ggg(X1, X2, X3)) -> lecA_out_ggg(s(X1), s(X2), X3) The set Q consists of the following terms: lecA_in_ggg(x0, x1, x2) U10_ggg(x0, x1, x2, x3) We have to consider all (P,Q,R)-chains. ---------------------------------------- (240) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule DIVB_IN_GGA(s(X1), s(X2)) -> U6_GGA(X1, X2, lecA_in_ggg(X2, X1, true)) we obtained the following new rules [LPAR04]: (DIVB_IN_GGA(s(z0), s(0)) -> U6_GGA(z0, 0, lecA_in_ggg(0, z0, true)),DIVB_IN_GGA(s(z0), s(0)) -> U6_GGA(z0, 0, lecA_in_ggg(0, z0, true))) ---------------------------------------- (241) Obligation: Q DP problem: The TRS P consists of the following rules: U6_GGA(x0, 0, lecA_out_ggg(0, x0, true)) -> U7_GGA(x0, 0, minuscC_out_gga(x0, 0, s(x0))) U7_GGA(z0, 0, minuscC_out_gga(z0, 0, s(z0))) -> DIVB_IN_GGA(s(z0), s(0)) DIVB_IN_GGA(s(z0), s(0)) -> U6_GGA(z0, 0, lecA_in_ggg(0, z0, true)) The TRS R consists of the following rules: lecA_in_ggg(0, X1, true) -> lecA_out_ggg(0, X1, true) lecA_in_ggg(s(X1), s(X2), X3) -> U10_ggg(X1, X2, X3, lecA_in_ggg(X1, X2, X3)) U10_ggg(X1, X2, X3, lecA_out_ggg(X1, X2, X3)) -> lecA_out_ggg(s(X1), s(X2), X3) The set Q consists of the following terms: lecA_in_ggg(x0, x1, x2) U10_ggg(x0, x1, x2, x3) We have to consider all (P,Q,R)-chains. ---------------------------------------- (242) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (243) Obligation: Q DP problem: The TRS P consists of the following rules: U6_GGA(x0, 0, lecA_out_ggg(0, x0, true)) -> U7_GGA(x0, 0, minuscC_out_gga(x0, 0, s(x0))) U7_GGA(z0, 0, minuscC_out_gga(z0, 0, s(z0))) -> DIVB_IN_GGA(s(z0), s(0)) DIVB_IN_GGA(s(z0), s(0)) -> U6_GGA(z0, 0, lecA_in_ggg(0, z0, true)) The TRS R consists of the following rules: lecA_in_ggg(0, X1, true) -> lecA_out_ggg(0, X1, true) The set Q consists of the following terms: lecA_in_ggg(x0, x1, x2) U10_ggg(x0, x1, x2, x3) We have to consider all (P,Q,R)-chains. ---------------------------------------- (244) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. U10_ggg(x0, x1, x2, x3) ---------------------------------------- (245) Obligation: Q DP problem: The TRS P consists of the following rules: U6_GGA(x0, 0, lecA_out_ggg(0, x0, true)) -> U7_GGA(x0, 0, minuscC_out_gga(x0, 0, s(x0))) U7_GGA(z0, 0, minuscC_out_gga(z0, 0, s(z0))) -> DIVB_IN_GGA(s(z0), s(0)) DIVB_IN_GGA(s(z0), s(0)) -> U6_GGA(z0, 0, lecA_in_ggg(0, z0, true)) The TRS R consists of the following rules: lecA_in_ggg(0, X1, true) -> lecA_out_ggg(0, X1, true) The set Q consists of the following terms: lecA_in_ggg(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (246) TransformationProof (EQUIVALENT) By rewriting [LPAR04] the rule DIVB_IN_GGA(s(z0), s(0)) -> U6_GGA(z0, 0, lecA_in_ggg(0, z0, true)) at position [2] we obtained the following new rules [LPAR04]: (DIVB_IN_GGA(s(z0), s(0)) -> U6_GGA(z0, 0, lecA_out_ggg(0, z0, true)),DIVB_IN_GGA(s(z0), s(0)) -> U6_GGA(z0, 0, lecA_out_ggg(0, z0, true))) ---------------------------------------- (247) Obligation: Q DP problem: The TRS P consists of the following rules: U6_GGA(x0, 0, lecA_out_ggg(0, x0, true)) -> U7_GGA(x0, 0, minuscC_out_gga(x0, 0, s(x0))) U7_GGA(z0, 0, minuscC_out_gga(z0, 0, s(z0))) -> DIVB_IN_GGA(s(z0), s(0)) DIVB_IN_GGA(s(z0), s(0)) -> U6_GGA(z0, 0, lecA_out_ggg(0, z0, true)) The TRS R consists of the following rules: lecA_in_ggg(0, X1, true) -> lecA_out_ggg(0, X1, true) The set Q consists of the following terms: lecA_in_ggg(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (248) UsableRulesProof (EQUIVALENT) As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R. ---------------------------------------- (249) Obligation: Q DP problem: The TRS P consists of the following rules: U6_GGA(x0, 0, lecA_out_ggg(0, x0, true)) -> U7_GGA(x0, 0, minuscC_out_gga(x0, 0, s(x0))) U7_GGA(z0, 0, minuscC_out_gga(z0, 0, s(z0))) -> DIVB_IN_GGA(s(z0), s(0)) DIVB_IN_GGA(s(z0), s(0)) -> U6_GGA(z0, 0, lecA_out_ggg(0, z0, true)) R is empty. The set Q consists of the following terms: lecA_in_ggg(x0, x1, x2) We have to consider all (P,Q,R)-chains. ---------------------------------------- (250) QReductionProof (EQUIVALENT) We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN]. lecA_in_ggg(x0, x1, x2) ---------------------------------------- (251) Obligation: Q DP problem: The TRS P consists of the following rules: U6_GGA(x0, 0, lecA_out_ggg(0, x0, true)) -> U7_GGA(x0, 0, minuscC_out_gga(x0, 0, s(x0))) U7_GGA(z0, 0, minuscC_out_gga(z0, 0, s(z0))) -> DIVB_IN_GGA(s(z0), s(0)) DIVB_IN_GGA(s(z0), s(0)) -> U6_GGA(z0, 0, lecA_out_ggg(0, z0, true)) R is empty. Q is empty. We have to consider all (P,Q,R)-chains. ---------------------------------------- (252) 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 = U7_GGA(z0', 0, minuscC_out_gga(z0', 0, s(z0'))) evaluates to t =U7_GGA(z0', 0, minuscC_out_gga(z0', 0, s(z0'))) Thus s starts an infinite chain as s semiunifies with t with the following substitutions: * Matcher: [ ] * Semiunifier: [ ] -------------------------------------------------------------------------------- Rewriting sequence U7_GGA(z0', 0, minuscC_out_gga(z0', 0, s(z0'))) -> DIVB_IN_GGA(s(z0'), s(0)) with rule U7_GGA(z0'', 0, minuscC_out_gga(z0'', 0, s(z0''))) -> DIVB_IN_GGA(s(z0''), s(0)) at position [] and matcher [z0'' / z0'] DIVB_IN_GGA(s(z0'), s(0)) -> U6_GGA(z0', 0, lecA_out_ggg(0, z0', true)) with rule DIVB_IN_GGA(s(z0), s(0)) -> U6_GGA(z0, 0, lecA_out_ggg(0, z0, true)) at position [] and matcher [z0 / z0'] U6_GGA(z0', 0, lecA_out_ggg(0, z0', true)) -> U7_GGA(z0', 0, minuscC_out_gga(z0', 0, s(z0'))) with rule U6_GGA(x0, 0, lecA_out_ggg(0, x0, true)) -> U7_GGA(x0, 0, minuscC_out_gga(x0, 0, s(x0))) 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. ---------------------------------------- (253) NO