/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: 794c25de1cacf0d048858bcd21c9a779e1221865 marcel 20200619 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, 8 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) TransformationProof [SOUND, 0 ms] (27) QDP (28) TransformationProof [SOUND, 0 ms] (29) QDP (30) TransformationProof [EQUIVALENT, 0 ms] (31) QDP (32) DependencyGraphProof [EQUIVALENT, 0 ms] (33) QDP (34) TransformationProof [EQUIVALENT, 0 ms] (35) QDP (36) TransformationProof [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) TransformationProof [EQUIVALENT, 0 ms] (45) QDP (46) DependencyGraphProof [EQUIVALENT, 0 ms] (47) AND (48) QDP (49) UsableRulesProof [EQUIVALENT, 0 ms] (50) QDP (51) QReductionProof [EQUIVALENT, 0 ms] (52) QDP (53) NonTerminationLoopProof [COMPLETE, 0 ms] (54) NO (55) QDP (56) TransformationProof [EQUIVALENT, 0 ms] (57) QDP (58) TransformationProof [EQUIVALENT, 0 ms] (59) QDP (60) QDPOrderProof [EQUIVALENT, 16 ms] (61) QDP (62) DependencyGraphProof [EQUIVALENT, 0 ms] (63) TRUE (64) PrologToPiTRSProof [SOUND, 0 ms] (65) PiTRS (66) DependencyPairsProof [EQUIVALENT, 1 ms] (67) PiDP (68) DependencyGraphProof [EQUIVALENT, 0 ms] (69) AND (70) PiDP (71) UsableRulesProof [EQUIVALENT, 0 ms] (72) PiDP (73) PiDPToQDPProof [SOUND, 0 ms] (74) QDP (75) QDPSizeChangeProof [EQUIVALENT, 0 ms] (76) YES (77) PiDP (78) UsableRulesProof [EQUIVALENT, 0 ms] (79) PiDP (80) PiDPToQDPProof [SOUND, 0 ms] (81) QDP (82) QDPSizeChangeProof [EQUIVALENT, 0 ms] (83) YES (84) PiDP (85) UsableRulesProof [EQUIVALENT, 0 ms] (86) PiDP (87) PiDPToQDPProof [SOUND, 0 ms] (88) QDP (89) QDPQMonotonicMRRProof [EQUIVALENT, 35 ms] (90) QDP (91) UsableRulesProof [EQUIVALENT, 0 ms] (92) QDP (93) QReductionProof [EQUIVALENT, 0 ms] (94) QDP (95) TransformationProof [SOUND, 0 ms] (96) QDP (97) UsableRulesProof [EQUIVALENT, 0 ms] (98) QDP (99) QReductionProof [EQUIVALENT, 0 ms] (100) QDP (101) TransformationProof [EQUIVALENT, 0 ms] (102) QDP (103) TransformationProof [EQUIVALENT, 0 ms] (104) QDP (105) TransformationProof [EQUIVALENT, 0 ms] (106) QDP (107) QDPQMonotonicMRRProof [EQUIVALENT, 13 ms] (108) QDP (109) TransformationProof [SOUND, 0 ms] (110) QDP (111) UsableRulesProof [EQUIVALENT, 0 ms] (112) QDP (113) TransformationProof [EQUIVALENT, 0 ms] (114) QDP (115) UsableRulesProof [EQUIVALENT, 0 ms] (116) QDP (117) QReductionProof [EQUIVALENT, 0 ms] (118) QDP (119) TransformationProof [EQUIVALENT, 0 ms] (120) QDP (121) UsableRulesProof [EQUIVALENT, 0 ms] (122) QDP (123) QReductionProof [EQUIVALENT, 0 ms] (124) QDP (125) TransformationProof [EQUIVALENT, 0 ms] (126) QDP (127) TransformationProof [EQUIVALENT, 0 ms] (128) QDP (129) TransformationProof [EQUIVALENT, 0 ms] (130) QDP (131) NonTerminationLoopProof [COMPLETE, 0 ms] (132) NO (133) PrologToTRSTransformerProof [SOUND, 0 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, 9 ms] (163) NO (164) PrologToDTProblemTransformerProof [SOUND, 39 ms] (165) TRIPLES (166) TriplesToPiDPProof [SOUND, 0 ms] (167) PiDP (168) DependencyGraphProof [EQUIVALENT, 0 ms] (169) AND (170) PiDP (171) UsableRulesProof [EQUIVALENT, 0 ms] (172) PiDP (173) PiDPToQDPProof [SOUND, 0 ms] (174) QDP (175) QDPSizeChangeProof [EQUIVALENT, 0 ms] (176) YES (177) PiDP (178) UsableRulesProof [EQUIVALENT, 0 ms] (179) PiDP (180) PiDPToQDPProof [SOUND, 1 ms] (181) QDP (182) QDPSizeChangeProof [EQUIVALENT, 0 ms] (183) YES (184) PiDP (185) PiDPToQDPProof [SOUND, 0 ms] (186) QDP (187) QDPQMonotonicMRRProof [EQUIVALENT, 34 ms] (188) QDP (189) QDPQMonotonicMRRProof [EQUIVALENT, 43 ms] (190) QDP (191) UsableRulesProof [EQUIVALENT, 0 ms] (192) QDP (193) QReductionProof [EQUIVALENT, 0 ms] (194) QDP (195) TransformationProof [SOUND, 0 ms] (196) QDP (197) UsableRulesProof [EQUIVALENT, 0 ms] (198) QDP (199) QReductionProof [EQUIVALENT, 0 ms] (200) QDP (201) TransformationProof [EQUIVALENT, 0 ms] (202) QDP (203) TransformationProof [EQUIVALENT, 0 ms] (204) QDP (205) UsableRulesProof [EQUIVALENT, 0 ms] (206) QDP (207) QReductionProof [EQUIVALENT, 0 ms] (208) QDP (209) TransformationProof [EQUIVALENT, 0 ms] (210) QDP (211) UsableRulesProof [EQUIVALENT, 0 ms] (212) QDP (213) QReductionProof [EQUIVALENT, 0 ms] (214) QDP (215) NonTerminationLoopProof [COMPLETE, 0 ms] (216) NO (217) PrologToIRSwTTransformerProof [SOUND, 56 ms] (218) AND (219) IRSwT (220) IRSwTSimpleDependencyGraphProof [EQUIVALENT, 0 ms] (221) TRUE (222) IRSwT (223) IRSwTSimpleDependencyGraphProof [EQUIVALENT, 0 ms] (224) IRSwT (225) IntTRSCompressionProof [EQUIVALENT, 2 ms] (226) IRSwT (227) IRSFormatTransformerProof [EQUIVALENT, 0 ms] (228) IRSwT (229) IRSwTTerminationDigraphProof [EQUIVALENT, 5 ms] (230) IRSwT (231) TempFilterProof [SOUND, 3 ms] (232) IRSwT (233) IRSwTToQDPProof [SOUND, 0 ms] (234) QDP (235) QDPSizeChangeProof [EQUIVALENT, 0 ms] (236) YES (237) IRSwT (238) IRSwTSimpleDependencyGraphProof [EQUIVALENT, 0 ms] (239) IRSwT (240) IntTRSCompressionProof [EQUIVALENT, 25 ms] (241) IRSwT (242) IRSFormatTransformerProof [EQUIVALENT, 0 ms] (243) IRSwT (244) IRSwTTerminationDigraphProof [EQUIVALENT, 63 ms] (245) IRSwT (246) IntTRSCompressionProof [EQUIVALENT, 7 ms] (247) IRSwT (248) IntTRSUnneededArgumentFilterProof [EQUIVALENT, 0 ms] (249) IRSwT (250) IRSwTToIntTRSProof [SOUND, 19 ms] (251) IRSwT (252) IntTRSCompressionProof [EQUIVALENT, 7 ms] (253) IRSwT ---------------------------------------- (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(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 ---------------------------------------- (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(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) ---------------------------------------- (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(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 ---------------------------------------- (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(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 ---------------------------------------- (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(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 ---------------------------------------- (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(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 ---------------------------------------- (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(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 ---------------------------------------- (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(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 ---------------------------------------- (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(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. ---------------------------------------- (26) 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)))) ---------------------------------------- (27) 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. ---------------------------------------- (28) 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)))) ---------------------------------------- (29) 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. ---------------------------------------- (30) 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))) ---------------------------------------- (31) 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. ---------------------------------------- (32) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes. ---------------------------------------- (33) 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. ---------------------------------------- (34) 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)))) ---------------------------------------- (35) 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. ---------------------------------------- (36) 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))) ---------------------------------------- (37) 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. ---------------------------------------- (38) 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)))) ---------------------------------------- (39) 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. ---------------------------------------- (40) 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)))) ---------------------------------------- (41) 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. ---------------------------------------- (42) 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))) ---------------------------------------- (43) 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. ---------------------------------------- (44) 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))) ---------------------------------------- (45) 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. ---------------------------------------- (46) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 2 SCCs. ---------------------------------------- (47) Complex Obligation (AND) ---------------------------------------- (48) 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. ---------------------------------------- (49) 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. ---------------------------------------- (50) 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. ---------------------------------------- (51) 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) ---------------------------------------- (52) 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. ---------------------------------------- (53) 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. ---------------------------------------- (54) NO ---------------------------------------- (55) 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. ---------------------------------------- (56) 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)))) ---------------------------------------- (57) 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. ---------------------------------------- (58) 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)))) ---------------------------------------- (59) 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. ---------------------------------------- (60) 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) ---------------------------------------- (61) 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. ---------------------------------------- (62) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 3 less nodes. ---------------------------------------- (63) TRUE ---------------------------------------- (64) 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 ---------------------------------------- (65) 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) ---------------------------------------- (66) 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 ---------------------------------------- (67) 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 ---------------------------------------- (68) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LOPSTR] contains 3 SCCs with 6 less nodes. ---------------------------------------- (69) Complex Obligation (AND) ---------------------------------------- (70) 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 ---------------------------------------- (71) UsableRulesProof (EQUIVALENT) For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R. ---------------------------------------- (72) 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 ---------------------------------------- (73) PiDPToQDPProof (SOUND) Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi. ---------------------------------------- (74) 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. ---------------------------------------- (75) 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 ---------------------------------------- (76) YES ---------------------------------------- (77) 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 ---------------------------------------- (78) UsableRulesProof (EQUIVALENT) For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R. ---------------------------------------- (79) 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 ---------------------------------------- (80) PiDPToQDPProof (SOUND) Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi. ---------------------------------------- (81) 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. ---------------------------------------- (82) 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 ---------------------------------------- (83) YES ---------------------------------------- (84) 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 ---------------------------------------- (85) UsableRulesProof (EQUIVALENT) For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R. ---------------------------------------- (86) 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 ---------------------------------------- (87) PiDPToQDPProof (SOUND) Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi. ---------------------------------------- (88) 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. ---------------------------------------- (89) 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 ---------------------------------------- (90) 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. ---------------------------------------- (91) 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. ---------------------------------------- (92) 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. ---------------------------------------- (93) 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) ---------------------------------------- (94) 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. ---------------------------------------- (95) 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))) ---------------------------------------- (96) 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. ---------------------------------------- (97) 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. ---------------------------------------- (98) 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. ---------------------------------------- (99) 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) ---------------------------------------- (100) 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. ---------------------------------------- (101) 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))) ---------------------------------------- (102) 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. ---------------------------------------- (103) 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))) ---------------------------------------- (104) 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. ---------------------------------------- (105) 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))) ---------------------------------------- (106) 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. ---------------------------------------- (107) QDPQMonotonicMRRProof (EQUIVALENT) By using the Q-monotonic rule removal processor with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented such that it always occurs at a strongly monotonic position in a (P,Q,R)-chain. Strictly oriented 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 ---------------------------------------- (108) 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. ---------------------------------------- (109) 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)))) ---------------------------------------- (110) 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. ---------------------------------------- (111) 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. ---------------------------------------- (112) 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. ---------------------------------------- (113) 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)))) ---------------------------------------- (114) 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. ---------------------------------------- (115) 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. ---------------------------------------- (116) 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. ---------------------------------------- (117) 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) ---------------------------------------- (118) 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. ---------------------------------------- (119) 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))) ---------------------------------------- (120) 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. ---------------------------------------- (121) 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. ---------------------------------------- (122) 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. ---------------------------------------- (123) 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) ---------------------------------------- (124) 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. ---------------------------------------- (125) 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))) ---------------------------------------- (126) 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. ---------------------------------------- (127) 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)))) ---------------------------------------- (128) 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. ---------------------------------------- (129) 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))) ---------------------------------------- (130) 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. ---------------------------------------- (131) 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. ---------------------------------------- (132) NO ---------------------------------------- (133) PrologToTRSTransformerProof (SOUND) Transformed Prolog program to TRS. { "root": 1, "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": { "47": { "goal": [{ "clause": -1, "scope": -1, "term": "(le (s T11) T10 X11)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11" ], "free": ["X11"], "exprvars": [] } }, "48": { "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": [] } }, "291": { "goal": [{ "clause": -1, "scope": -1, "term": "(le T42 T43 X57)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T42", "T43" ], "free": ["X57"], "exprvars": [] } }, "390": { "goal": [{ "clause": 3, "scope": 5, "term": "(minus T66 T67 X84)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T66", "T67" ], "free": ["X84"], "exprvars": [] } }, "270": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "292": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "391": { "goal": [{ "clause": 4, "scope": 5, "term": "(minus T66 T67 X84)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T66", "T67" ], "free": ["X84"], "exprvars": [] } }, "type": "Nodes", "271": { "goal": [{ "clause": -1, "scope": -1, "term": "(le T24 T25 X33)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T24", "T25" ], "free": ["X33"], "exprvars": [] } }, "392": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "272": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "393": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "273": { "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": [] } }, "274": { "goal": [{ "clause": 0, "scope": 3, "term": "(le T24 T25 X33)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T24", "T25" ], "free": ["X33"], "exprvars": [] } }, "373": { "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": [] } }, "395": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "253": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "275": { "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": [] } }, "374": { "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": [] } }, "276": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "397": { "goal": [{ "clause": -1, "scope": -1, "term": "(minus T84 T85 X105)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T84", "T85" ], "free": ["X105"], "exprvars": [] } }, "277": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "278": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "377": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "399": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "279": { "goal": [{ "clause": 1, "scope": 3, "term": "(le T24 T25 X33)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T24", "T25" ], "free": ["X33"], "exprvars": [] } }, "378": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "379": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "50": { "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": [] } }, "52": { "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": [] } }, "53": { "goal": [{ "clause": 1, "scope": 2, "term": "(le (s T11) T10 X11)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11" ], "free": ["X11"], "exprvars": [] } }, "54": { "goal": [{ "clause": 2, "scope": 2, "term": "(le (s T11) T10 X11)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11" ], "free": ["X11"], "exprvars": [] } }, "14": { "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": [] } }, "15": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "280": { "goal": [{ "clause": 2, "scope": 3, "term": "(le T24 T25 X33)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T24", "T25" ], "free": ["X33"], "exprvars": [] } }, "281": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "283": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "383": { "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": [] } }, "285": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "384": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "264": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "1": { "goal": [{ "clause": -1, "scope": -1, "term": "(div T1 T2 T3)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T1", "T2" ], "free": [], "exprvars": [] } }, "387": { "goal": [{ "clause": -1, "scope": -1, "term": "(minus T66 T67 X84)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T66", "T67" ], "free": ["X84"], "exprvars": [] } }, "322": { "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": [] } }, "388": { "goal": [{ "clause": -1, "scope": -1, "term": "(div T72 (s T67) T69)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T67", "T72" ], "free": [], "exprvars": [] } }, "389": { "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": [] } }, "5": { "goal": [{ "clause": 5, "scope": 1, "term": "(div T1 T2 T3)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T1", "T2" ], "free": [], "exprvars": [] } } }, "edges": [ { "from": 1, "to": 5, "label": "CASE" }, { "from": 5, "to": 14, "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": 5, "to": 15, "label": "EVAL-BACKTRACK" }, { "from": 14, "to": 47, "label": "SPLIT 1" }, { "from": 14, "to": 48, "label": "SPLIT 2\nnew knowledge:\nT11 is ground\nT10 is ground\nT14 is ground\nreplacements:X11 -> T14" }, { "from": 47, "to": 50, "label": "CASE" }, { "from": 48, "to": 322, "label": "CASE" }, { "from": 50, "to": 52, "label": "BACKTRACK\nfor clause: le(0, Y, true)because of non-unification" }, { "from": 52, "to": 53, "label": "PARALLEL" }, { "from": 52, "to": 54, "label": "PARALLEL" }, { "from": 53, "to": 253, "label": "EVAL with clause\nle(s(X21), 0, false).\nand substitutionT11 -> T19,\nX21 -> T19,\nT10 -> 0,\nX11 -> false" }, { "from": 53, "to": 264, "label": "EVAL-BACKTRACK" }, { "from": 54, "to": 271, "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": 54, "to": 272, "label": "EVAL-BACKTRACK" }, { "from": 253, "to": 270, "label": "SUCCESS" }, { "from": 271, "to": 273, "label": "CASE" }, { "from": 273, "to": 274, "label": "PARALLEL" }, { "from": 273, "to": 275, "label": "PARALLEL" }, { "from": 274, "to": 276, "label": "EVAL with clause\nle(0, X40, true).\nand substitutionT24 -> 0,\nT25 -> T32,\nX40 -> T32,\nX33 -> true" }, { "from": 274, "to": 277, "label": "EVAL-BACKTRACK" }, { "from": 275, "to": 279, "label": "PARALLEL" }, { "from": 275, "to": 280, "label": "PARALLEL" }, { "from": 276, "to": 278, "label": "SUCCESS" }, { "from": 279, "to": 281, "label": "EVAL with clause\nle(s(X45), 0, false).\nand substitutionX45 -> T37,\nT24 -> s(T37),\nT25 -> 0,\nX33 -> false" }, { "from": 279, "to": 283, "label": "EVAL-BACKTRACK" }, { "from": 280, "to": 291, "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": 280, "to": 292, "label": "EVAL-BACKTRACK" }, { "from": 281, "to": 285, "label": "SUCCESS" }, { "from": 291, "to": 271, "label": "INSTANCE with matching:\nT24 -> T42\nT25 -> T43\nX33 -> X57" }, { "from": 322, "to": 373, "label": "PARALLEL" }, { "from": 322, "to": 374, "label": "PARALLEL" }, { "from": 373, "to": 377, "label": "EVAL with clause\nif(false, X72, s(X73), 0).\nand substitutionT14 -> false,\nT10 -> T58,\nX72 -> T58,\nT11 -> T59,\nX73 -> T59,\nT13 -> 0" }, { "from": 373, "to": 378, "label": "EVAL-BACKTRACK" }, { "from": 374, "to": 383, "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": 374, "to": 384, "label": "EVAL-BACKTRACK" }, { "from": 377, "to": 379, "label": "SUCCESS" }, { "from": 383, "to": 387, "label": "SPLIT 1" }, { "from": 383, "to": 388, "label": "SPLIT 2\nnew knowledge:\nT66 is ground\nT67 is ground\nT72 is ground\nreplacements:X84 -> T72" }, { "from": 387, "to": 389, "label": "CASE" }, { "from": 388, "to": 1, "label": "INSTANCE with matching:\nT1 -> T72\nT2 -> s(T67)\nT3 -> T69" }, { "from": 389, "to": 390, "label": "PARALLEL" }, { "from": 389, "to": 391, "label": "PARALLEL" }, { "from": 390, "to": 392, "label": "EVAL with clause\nminus(X93, 0, X93).\nand substitutionT66 -> T79,\nX93 -> T79,\nT67 -> 0,\nX84 -> T79" }, { "from": 390, "to": 393, "label": "EVAL-BACKTRACK" }, { "from": 391, "to": 397, "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": 391, "to": 399, "label": "EVAL-BACKTRACK" }, { "from": 392, "to": 395, "label": "SUCCESS" }, { "from": 397, "to": 387, "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: f1_in(T10, s(T11)) -> U1(f14_in(T11, T10), T10, s(T11)) U1(f14_out1(X11, T13), T10, s(T11)) -> f1_out1(T13) f271_in(0, T32) -> f271_out1(true) f271_in(s(T37), 0) -> f271_out1(false) f271_in(s(T42), s(T43)) -> U2(f271_in(T42, T43), s(T42), s(T43)) U2(f271_out1(X57), s(T42), s(T43)) -> f271_out1(X57) f387_in(T79, 0) -> f387_out1(T79) f387_in(s(T84), s(T85)) -> U3(f387_in(T84, T85), s(T84), s(T85)) U3(f387_out1(X105), s(T84), s(T85)) -> f387_out1(X105) f47_in(T19, 0) -> f47_out1(false) f47_in(T24, s(T25)) -> U4(f271_in(T24, T25), T24, s(T25)) U4(f271_out1(X33), T24, s(T25)) -> f47_out1(X33) f48_in(false, T58, T59) -> f48_out1(0) f48_in(true, T66, T67) -> U5(f383_in(T66, T67), true, T66, T67) U5(f383_out1(X84, T69), true, T66, T67) -> f48_out1(s(T69)) f14_in(T11, T10) -> U6(f47_in(T11, T10), T11, T10) U6(f47_out1(T14), T11, T10) -> U7(f48_in(T14, T10, T11), T11, T10, T14) U7(f48_out1(T13), T11, T10, T14) -> f14_out1(T14, T13) f383_in(T66, T67) -> U8(f387_in(T66, T67), T66, T67) U8(f387_out1(T72), T66, T67) -> U9(f1_in(T72, s(T67)), T66, T67, T72) U9(f1_out1(T69), T66, T67, T72) -> f383_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: f1_in(T10, s(T11)) -> U1(f14_in(T11, T10), T10, s(T11)) U1(f14_out1(X11, T13), T10, s(T11)) -> f1_out1(T13) f271_in(0, T32) -> f271_out1(true) f271_in(s(T37), 0) -> f271_out1(false) f271_in(s(T42), s(T43)) -> U2(f271_in(T42, T43), s(T42), s(T43)) U2(f271_out1(X57), s(T42), s(T43)) -> f271_out1(X57) f387_in(T79, 0) -> f387_out1(T79) f387_in(s(T84), s(T85)) -> U3(f387_in(T84, T85), s(T84), s(T85)) U3(f387_out1(X105), s(T84), s(T85)) -> f387_out1(X105) f47_in(T19, 0) -> f47_out1(false) f47_in(T24, s(T25)) -> U4(f271_in(T24, T25), T24, s(T25)) U4(f271_out1(X33), T24, s(T25)) -> f47_out1(X33) f48_in(false, T58, T59) -> f48_out1(0) f48_in(true, T66, T67) -> U5(f383_in(T66, T67), true, T66, T67) U5(f383_out1(X84, T69), true, T66, T67) -> f48_out1(s(T69)) f14_in(T11, T10) -> U6(f47_in(T11, T10), T11, T10) U6(f47_out1(T14), T11, T10) -> U7(f48_in(T14, T10, T11), T11, T10, T14) U7(f48_out1(T13), T11, T10, T14) -> f14_out1(T14, T13) f383_in(T66, T67) -> U8(f387_in(T66, T67), T66, T67) U8(f387_out1(T72), T66, T67) -> U9(f1_in(T72, s(T67)), T66, T67, T72) U9(f1_out1(T69), T66, T67, T72) -> f383_out1(T72, T69) The set Q consists of the following terms: f1_in(x0, s(x1)) U1(f14_out1(x0, x1), x2, s(x3)) f271_in(0, x0) f271_in(s(x0), 0) f271_in(s(x0), s(x1)) U2(f271_out1(x0), s(x1), s(x2)) f387_in(x0, 0) f387_in(s(x0), s(x1)) U3(f387_out1(x0), s(x1), s(x2)) f47_in(x0, 0) f47_in(x0, s(x1)) U4(f271_out1(x0), x1, s(x2)) f48_in(false, x0, x1) f48_in(true, x0, x1) U5(f383_out1(x0, x1), true, x2, x3) f14_in(x0, x1) U6(f47_out1(x0), x1, x2) U7(f48_out1(x0), x1, x2, x3) f383_in(x0, x1) U8(f387_out1(x0), x1, x2) U9(f1_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: F1_IN(T10, s(T11)) -> U1^1(f14_in(T11, T10), T10, s(T11)) F1_IN(T10, s(T11)) -> F14_IN(T11, T10) F271_IN(s(T42), s(T43)) -> U2^1(f271_in(T42, T43), s(T42), s(T43)) F271_IN(s(T42), s(T43)) -> F271_IN(T42, T43) F387_IN(s(T84), s(T85)) -> U3^1(f387_in(T84, T85), s(T84), s(T85)) F387_IN(s(T84), s(T85)) -> F387_IN(T84, T85) F47_IN(T24, s(T25)) -> U4^1(f271_in(T24, T25), T24, s(T25)) F47_IN(T24, s(T25)) -> F271_IN(T24, T25) F48_IN(true, T66, T67) -> U5^1(f383_in(T66, T67), true, T66, T67) F48_IN(true, T66, T67) -> F383_IN(T66, T67) F14_IN(T11, T10) -> U6^1(f47_in(T11, T10), T11, T10) F14_IN(T11, T10) -> F47_IN(T11, T10) U6^1(f47_out1(T14), T11, T10) -> U7^1(f48_in(T14, T10, T11), T11, T10, T14) U6^1(f47_out1(T14), T11, T10) -> F48_IN(T14, T10, T11) F383_IN(T66, T67) -> U8^1(f387_in(T66, T67), T66, T67) F383_IN(T66, T67) -> F387_IN(T66, T67) U8^1(f387_out1(T72), T66, T67) -> U9^1(f1_in(T72, s(T67)), T66, T67, T72) U8^1(f387_out1(T72), T66, T67) -> F1_IN(T72, s(T67)) The TRS R consists of the following rules: f1_in(T10, s(T11)) -> U1(f14_in(T11, T10), T10, s(T11)) U1(f14_out1(X11, T13), T10, s(T11)) -> f1_out1(T13) f271_in(0, T32) -> f271_out1(true) f271_in(s(T37), 0) -> f271_out1(false) f271_in(s(T42), s(T43)) -> U2(f271_in(T42, T43), s(T42), s(T43)) U2(f271_out1(X57), s(T42), s(T43)) -> f271_out1(X57) f387_in(T79, 0) -> f387_out1(T79) f387_in(s(T84), s(T85)) -> U3(f387_in(T84, T85), s(T84), s(T85)) U3(f387_out1(X105), s(T84), s(T85)) -> f387_out1(X105) f47_in(T19, 0) -> f47_out1(false) f47_in(T24, s(T25)) -> U4(f271_in(T24, T25), T24, s(T25)) U4(f271_out1(X33), T24, s(T25)) -> f47_out1(X33) f48_in(false, T58, T59) -> f48_out1(0) f48_in(true, T66, T67) -> U5(f383_in(T66, T67), true, T66, T67) U5(f383_out1(X84, T69), true, T66, T67) -> f48_out1(s(T69)) f14_in(T11, T10) -> U6(f47_in(T11, T10), T11, T10) U6(f47_out1(T14), T11, T10) -> U7(f48_in(T14, T10, T11), T11, T10, T14) U7(f48_out1(T13), T11, T10, T14) -> f14_out1(T14, T13) f383_in(T66, T67) -> U8(f387_in(T66, T67), T66, T67) U8(f387_out1(T72), T66, T67) -> U9(f1_in(T72, s(T67)), T66, T67, T72) U9(f1_out1(T69), T66, T67, T72) -> f383_out1(T72, T69) The set Q consists of the following terms: f1_in(x0, s(x1)) U1(f14_out1(x0, x1), x2, s(x3)) f271_in(0, x0) f271_in(s(x0), 0) f271_in(s(x0), s(x1)) U2(f271_out1(x0), s(x1), s(x2)) f387_in(x0, 0) f387_in(s(x0), s(x1)) U3(f387_out1(x0), s(x1), s(x2)) f47_in(x0, 0) f47_in(x0, s(x1)) U4(f271_out1(x0), x1, s(x2)) f48_in(false, x0, x1) f48_in(true, x0, x1) U5(f383_out1(x0, x1), true, x2, x3) f14_in(x0, x1) U6(f47_out1(x0), x1, x2) U7(f48_out1(x0), x1, x2, x3) f383_in(x0, x1) U8(f387_out1(x0), x1, x2) U9(f1_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: F387_IN(s(T84), s(T85)) -> F387_IN(T84, T85) The TRS R consists of the following rules: f1_in(T10, s(T11)) -> U1(f14_in(T11, T10), T10, s(T11)) U1(f14_out1(X11, T13), T10, s(T11)) -> f1_out1(T13) f271_in(0, T32) -> f271_out1(true) f271_in(s(T37), 0) -> f271_out1(false) f271_in(s(T42), s(T43)) -> U2(f271_in(T42, T43), s(T42), s(T43)) U2(f271_out1(X57), s(T42), s(T43)) -> f271_out1(X57) f387_in(T79, 0) -> f387_out1(T79) f387_in(s(T84), s(T85)) -> U3(f387_in(T84, T85), s(T84), s(T85)) U3(f387_out1(X105), s(T84), s(T85)) -> f387_out1(X105) f47_in(T19, 0) -> f47_out1(false) f47_in(T24, s(T25)) -> U4(f271_in(T24, T25), T24, s(T25)) U4(f271_out1(X33), T24, s(T25)) -> f47_out1(X33) f48_in(false, T58, T59) -> f48_out1(0) f48_in(true, T66, T67) -> U5(f383_in(T66, T67), true, T66, T67) U5(f383_out1(X84, T69), true, T66, T67) -> f48_out1(s(T69)) f14_in(T11, T10) -> U6(f47_in(T11, T10), T11, T10) U6(f47_out1(T14), T11, T10) -> U7(f48_in(T14, T10, T11), T11, T10, T14) U7(f48_out1(T13), T11, T10, T14) -> f14_out1(T14, T13) f383_in(T66, T67) -> U8(f387_in(T66, T67), T66, T67) U8(f387_out1(T72), T66, T67) -> U9(f1_in(T72, s(T67)), T66, T67, T72) U9(f1_out1(T69), T66, T67, T72) -> f383_out1(T72, T69) The set Q consists of the following terms: f1_in(x0, s(x1)) U1(f14_out1(x0, x1), x2, s(x3)) f271_in(0, x0) f271_in(s(x0), 0) f271_in(s(x0), s(x1)) U2(f271_out1(x0), s(x1), s(x2)) f387_in(x0, 0) f387_in(s(x0), s(x1)) U3(f387_out1(x0), s(x1), s(x2)) f47_in(x0, 0) f47_in(x0, s(x1)) U4(f271_out1(x0), x1, s(x2)) f48_in(false, x0, x1) f48_in(true, x0, x1) U5(f383_out1(x0, x1), true, x2, x3) f14_in(x0, x1) U6(f47_out1(x0), x1, x2) U7(f48_out1(x0), x1, x2, x3) f383_in(x0, x1) U8(f387_out1(x0), x1, x2) U9(f1_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: F387_IN(s(T84), s(T85)) -> F387_IN(T84, T85) R is empty. The set Q consists of the following terms: f1_in(x0, s(x1)) U1(f14_out1(x0, x1), x2, s(x3)) f271_in(0, x0) f271_in(s(x0), 0) f271_in(s(x0), s(x1)) U2(f271_out1(x0), s(x1), s(x2)) f387_in(x0, 0) f387_in(s(x0), s(x1)) U3(f387_out1(x0), s(x1), s(x2)) f47_in(x0, 0) f47_in(x0, s(x1)) U4(f271_out1(x0), x1, s(x2)) f48_in(false, x0, x1) f48_in(true, x0, x1) U5(f383_out1(x0, x1), true, x2, x3) f14_in(x0, x1) U6(f47_out1(x0), x1, x2) U7(f48_out1(x0), x1, x2, x3) f383_in(x0, x1) U8(f387_out1(x0), x1, x2) U9(f1_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]. f1_in(x0, s(x1)) U1(f14_out1(x0, x1), x2, s(x3)) f271_in(0, x0) f271_in(s(x0), 0) f271_in(s(x0), s(x1)) U2(f271_out1(x0), s(x1), s(x2)) f387_in(x0, 0) f387_in(s(x0), s(x1)) U3(f387_out1(x0), s(x1), s(x2)) f47_in(x0, 0) f47_in(x0, s(x1)) U4(f271_out1(x0), x1, s(x2)) f48_in(false, x0, x1) f48_in(true, x0, x1) U5(f383_out1(x0, x1), true, x2, x3) f14_in(x0, x1) U6(f47_out1(x0), x1, x2) U7(f48_out1(x0), x1, x2, x3) f383_in(x0, x1) U8(f387_out1(x0), x1, x2) U9(f1_out1(x0), x1, x2, x3) ---------------------------------------- (145) Obligation: Q DP problem: The TRS P consists of the following rules: F387_IN(s(T84), s(T85)) -> F387_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: *F387_IN(s(T84), s(T85)) -> F387_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: F271_IN(s(T42), s(T43)) -> F271_IN(T42, T43) The TRS R consists of the following rules: f1_in(T10, s(T11)) -> U1(f14_in(T11, T10), T10, s(T11)) U1(f14_out1(X11, T13), T10, s(T11)) -> f1_out1(T13) f271_in(0, T32) -> f271_out1(true) f271_in(s(T37), 0) -> f271_out1(false) f271_in(s(T42), s(T43)) -> U2(f271_in(T42, T43), s(T42), s(T43)) U2(f271_out1(X57), s(T42), s(T43)) -> f271_out1(X57) f387_in(T79, 0) -> f387_out1(T79) f387_in(s(T84), s(T85)) -> U3(f387_in(T84, T85), s(T84), s(T85)) U3(f387_out1(X105), s(T84), s(T85)) -> f387_out1(X105) f47_in(T19, 0) -> f47_out1(false) f47_in(T24, s(T25)) -> U4(f271_in(T24, T25), T24, s(T25)) U4(f271_out1(X33), T24, s(T25)) -> f47_out1(X33) f48_in(false, T58, T59) -> f48_out1(0) f48_in(true, T66, T67) -> U5(f383_in(T66, T67), true, T66, T67) U5(f383_out1(X84, T69), true, T66, T67) -> f48_out1(s(T69)) f14_in(T11, T10) -> U6(f47_in(T11, T10), T11, T10) U6(f47_out1(T14), T11, T10) -> U7(f48_in(T14, T10, T11), T11, T10, T14) U7(f48_out1(T13), T11, T10, T14) -> f14_out1(T14, T13) f383_in(T66, T67) -> U8(f387_in(T66, T67), T66, T67) U8(f387_out1(T72), T66, T67) -> U9(f1_in(T72, s(T67)), T66, T67, T72) U9(f1_out1(T69), T66, T67, T72) -> f383_out1(T72, T69) The set Q consists of the following terms: f1_in(x0, s(x1)) U1(f14_out1(x0, x1), x2, s(x3)) f271_in(0, x0) f271_in(s(x0), 0) f271_in(s(x0), s(x1)) U2(f271_out1(x0), s(x1), s(x2)) f387_in(x0, 0) f387_in(s(x0), s(x1)) U3(f387_out1(x0), s(x1), s(x2)) f47_in(x0, 0) f47_in(x0, s(x1)) U4(f271_out1(x0), x1, s(x2)) f48_in(false, x0, x1) f48_in(true, x0, x1) U5(f383_out1(x0, x1), true, x2, x3) f14_in(x0, x1) U6(f47_out1(x0), x1, x2) U7(f48_out1(x0), x1, x2, x3) f383_in(x0, x1) U8(f387_out1(x0), x1, x2) U9(f1_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: F271_IN(s(T42), s(T43)) -> F271_IN(T42, T43) R is empty. The set Q consists of the following terms: f1_in(x0, s(x1)) U1(f14_out1(x0, x1), x2, s(x3)) f271_in(0, x0) f271_in(s(x0), 0) f271_in(s(x0), s(x1)) U2(f271_out1(x0), s(x1), s(x2)) f387_in(x0, 0) f387_in(s(x0), s(x1)) U3(f387_out1(x0), s(x1), s(x2)) f47_in(x0, 0) f47_in(x0, s(x1)) U4(f271_out1(x0), x1, s(x2)) f48_in(false, x0, x1) f48_in(true, x0, x1) U5(f383_out1(x0, x1), true, x2, x3) f14_in(x0, x1) U6(f47_out1(x0), x1, x2) U7(f48_out1(x0), x1, x2, x3) f383_in(x0, x1) U8(f387_out1(x0), x1, x2) U9(f1_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]. f1_in(x0, s(x1)) U1(f14_out1(x0, x1), x2, s(x3)) f271_in(0, x0) f271_in(s(x0), 0) f271_in(s(x0), s(x1)) U2(f271_out1(x0), s(x1), s(x2)) f387_in(x0, 0) f387_in(s(x0), s(x1)) U3(f387_out1(x0), s(x1), s(x2)) f47_in(x0, 0) f47_in(x0, s(x1)) U4(f271_out1(x0), x1, s(x2)) f48_in(false, x0, x1) f48_in(true, x0, x1) U5(f383_out1(x0, x1), true, x2, x3) f14_in(x0, x1) U6(f47_out1(x0), x1, x2) U7(f48_out1(x0), x1, x2, x3) f383_in(x0, x1) U8(f387_out1(x0), x1, x2) U9(f1_out1(x0), x1, x2, x3) ---------------------------------------- (152) Obligation: Q DP problem: The TRS P consists of the following rules: F271_IN(s(T42), s(T43)) -> F271_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: *F271_IN(s(T42), s(T43)) -> F271_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: F1_IN(T10, s(T11)) -> F14_IN(T11, T10) F14_IN(T11, T10) -> U6^1(f47_in(T11, T10), T11, T10) U6^1(f47_out1(T14), T11, T10) -> F48_IN(T14, T10, T11) F48_IN(true, T66, T67) -> F383_IN(T66, T67) F383_IN(T66, T67) -> U8^1(f387_in(T66, T67), T66, T67) U8^1(f387_out1(T72), T66, T67) -> F1_IN(T72, s(T67)) The TRS R consists of the following rules: f1_in(T10, s(T11)) -> U1(f14_in(T11, T10), T10, s(T11)) U1(f14_out1(X11, T13), T10, s(T11)) -> f1_out1(T13) f271_in(0, T32) -> f271_out1(true) f271_in(s(T37), 0) -> f271_out1(false) f271_in(s(T42), s(T43)) -> U2(f271_in(T42, T43), s(T42), s(T43)) U2(f271_out1(X57), s(T42), s(T43)) -> f271_out1(X57) f387_in(T79, 0) -> f387_out1(T79) f387_in(s(T84), s(T85)) -> U3(f387_in(T84, T85), s(T84), s(T85)) U3(f387_out1(X105), s(T84), s(T85)) -> f387_out1(X105) f47_in(T19, 0) -> f47_out1(false) f47_in(T24, s(T25)) -> U4(f271_in(T24, T25), T24, s(T25)) U4(f271_out1(X33), T24, s(T25)) -> f47_out1(X33) f48_in(false, T58, T59) -> f48_out1(0) f48_in(true, T66, T67) -> U5(f383_in(T66, T67), true, T66, T67) U5(f383_out1(X84, T69), true, T66, T67) -> f48_out1(s(T69)) f14_in(T11, T10) -> U6(f47_in(T11, T10), T11, T10) U6(f47_out1(T14), T11, T10) -> U7(f48_in(T14, T10, T11), T11, T10, T14) U7(f48_out1(T13), T11, T10, T14) -> f14_out1(T14, T13) f383_in(T66, T67) -> U8(f387_in(T66, T67), T66, T67) U8(f387_out1(T72), T66, T67) -> U9(f1_in(T72, s(T67)), T66, T67, T72) U9(f1_out1(T69), T66, T67, T72) -> f383_out1(T72, T69) The set Q consists of the following terms: f1_in(x0, s(x1)) U1(f14_out1(x0, x1), x2, s(x3)) f271_in(0, x0) f271_in(s(x0), 0) f271_in(s(x0), s(x1)) U2(f271_out1(x0), s(x1), s(x2)) f387_in(x0, 0) f387_in(s(x0), s(x1)) U3(f387_out1(x0), s(x1), s(x2)) f47_in(x0, 0) f47_in(x0, s(x1)) U4(f271_out1(x0), x1, s(x2)) f48_in(false, x0, x1) f48_in(true, x0, x1) U5(f383_out1(x0, x1), true, x2, x3) f14_in(x0, x1) U6(f47_out1(x0), x1, x2) U7(f48_out1(x0), x1, x2, x3) f383_in(x0, x1) U8(f387_out1(x0), x1, x2) U9(f1_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: F1_IN(T10, s(T11)) -> F14_IN(T11, T10) F14_IN(T11, T10) -> U6^1(f47_in(T11, T10), T11, T10) U6^1(f47_out1(T14), T11, T10) -> F48_IN(T14, T10, T11) F48_IN(true, T66, T67) -> F383_IN(T66, T67) F383_IN(T66, T67) -> U8^1(f387_in(T66, T67), T66, T67) U8^1(f387_out1(T72), T66, T67) -> F1_IN(T72, s(T67)) The TRS R consists of the following rules: f387_in(T79, 0) -> f387_out1(T79) f387_in(s(T84), s(T85)) -> U3(f387_in(T84, T85), s(T84), s(T85)) U3(f387_out1(X105), s(T84), s(T85)) -> f387_out1(X105) f47_in(T19, 0) -> f47_out1(false) f47_in(T24, s(T25)) -> U4(f271_in(T24, T25), T24, s(T25)) f271_in(0, T32) -> f271_out1(true) f271_in(s(T37), 0) -> f271_out1(false) f271_in(s(T42), s(T43)) -> U2(f271_in(T42, T43), s(T42), s(T43)) U4(f271_out1(X33), T24, s(T25)) -> f47_out1(X33) U2(f271_out1(X57), s(T42), s(T43)) -> f271_out1(X57) The set Q consists of the following terms: f1_in(x0, s(x1)) U1(f14_out1(x0, x1), x2, s(x3)) f271_in(0, x0) f271_in(s(x0), 0) f271_in(s(x0), s(x1)) U2(f271_out1(x0), s(x1), s(x2)) f387_in(x0, 0) f387_in(s(x0), s(x1)) U3(f387_out1(x0), s(x1), s(x2)) f47_in(x0, 0) f47_in(x0, s(x1)) U4(f271_out1(x0), x1, s(x2)) f48_in(false, x0, x1) f48_in(true, x0, x1) U5(f383_out1(x0, x1), true, x2, x3) f14_in(x0, x1) U6(f47_out1(x0), x1, x2) U7(f48_out1(x0), x1, x2, x3) f383_in(x0, x1) U8(f387_out1(x0), x1, x2) U9(f1_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]. f1_in(x0, s(x1)) U1(f14_out1(x0, x1), x2, s(x3)) f48_in(false, x0, x1) f48_in(true, x0, x1) U5(f383_out1(x0, x1), true, x2, x3) f14_in(x0, x1) U6(f47_out1(x0), x1, x2) U7(f48_out1(x0), x1, x2, x3) f383_in(x0, x1) U8(f387_out1(x0), x1, x2) U9(f1_out1(x0), x1, x2, x3) ---------------------------------------- (159) Obligation: Q DP problem: The TRS P consists of the following rules: F1_IN(T10, s(T11)) -> F14_IN(T11, T10) F14_IN(T11, T10) -> U6^1(f47_in(T11, T10), T11, T10) U6^1(f47_out1(T14), T11, T10) -> F48_IN(T14, T10, T11) F48_IN(true, T66, T67) -> F383_IN(T66, T67) F383_IN(T66, T67) -> U8^1(f387_in(T66, T67), T66, T67) U8^1(f387_out1(T72), T66, T67) -> F1_IN(T72, s(T67)) The TRS R consists of the following rules: f387_in(T79, 0) -> f387_out1(T79) f387_in(s(T84), s(T85)) -> U3(f387_in(T84, T85), s(T84), s(T85)) U3(f387_out1(X105), s(T84), s(T85)) -> f387_out1(X105) f47_in(T19, 0) -> f47_out1(false) f47_in(T24, s(T25)) -> U4(f271_in(T24, T25), T24, s(T25)) f271_in(0, T32) -> f271_out1(true) f271_in(s(T37), 0) -> f271_out1(false) f271_in(s(T42), s(T43)) -> U2(f271_in(T42, T43), s(T42), s(T43)) U4(f271_out1(X33), T24, s(T25)) -> f47_out1(X33) U2(f271_out1(X57), s(T42), s(T43)) -> f271_out1(X57) The set Q consists of the following terms: f271_in(0, x0) f271_in(s(x0), 0) f271_in(s(x0), s(x1)) U2(f271_out1(x0), s(x1), s(x2)) f387_in(x0, 0) f387_in(s(x0), s(x1)) U3(f387_out1(x0), s(x1), s(x2)) f47_in(x0, 0) f47_in(x0, s(x1)) U4(f271_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: F1_IN(T10, s(T11)) -> F14_IN(T11, T10) F14_IN(T11, T10) -> U6^1(f47_in(T11, T10), T11, T10) U6^1(f47_out1(T14), T11, T10) -> F48_IN(T14, T10, T11) F48_IN(true, T66, T67) -> F383_IN(T66, T67) F383_IN(T66, T67) -> U8^1(f387_in(T66, T67), T66, T67) U8^1(f387_out1(T72), T66, T67) -> F1_IN(T72, s(T67)) The TRS R consists of the following rules: f387_in(T79, 0) -> f387_out1(T79) f387_in(s(T84), s(T85)) -> U3(f387_in(T84, T85), s(T84), s(T85)) U3(f387_out1(X105), s(T84), s(T85)) -> f387_out1(X105) f47_in(T19, 0) -> f47_out1(false) f47_in(T24, s(T25)) -> U4(f271_in(T24, T25), T24, s(T25)) f271_in(0, T32) -> f271_out1(true) f271_in(s(T37), 0) -> f271_out1(false) f271_in(s(T42), s(T43)) -> U2(f271_in(T42, T43), s(T42), s(T43)) U4(f271_out1(X33), T24, s(T25)) -> f47_out1(X33) U2(f271_out1(X57), s(T42), s(T43)) -> f271_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 = F14_IN(0, s(T25')) evaluates to t =F14_IN(0, s(T25')) Thus s starts an infinite chain as s semiunifies with t with the following substitutions: * Matcher: [ ] * Semiunifier: [ ] -------------------------------------------------------------------------------- Rewriting sequence F14_IN(0, s(T25')) -> U6^1(f47_in(0, s(T25')), 0, s(T25')) with rule F14_IN(T11, T10') -> U6^1(f47_in(T11, T10'), T11, T10') at position [] and matcher [T11 / 0, T10' / s(T25')] U6^1(f47_in(0, s(T25')), 0, s(T25')) -> U6^1(U4(f271_in(0, T25'), 0, s(T25')), 0, s(T25')) with rule f47_in(T24', s(T25'')) -> U4(f271_in(T24', T25''), T24', s(T25'')) at position [0] and matcher [T24' / 0, T25'' / T25'] U6^1(U4(f271_in(0, T25'), 0, s(T25')), 0, s(T25')) -> U6^1(U4(f271_out1(true), 0, s(T25')), 0, s(T25')) with rule f271_in(0, T32) -> f271_out1(true) at position [0,0] and matcher [T32 / T25'] U6^1(U4(f271_out1(true), 0, s(T25')), 0, s(T25')) -> U6^1(f47_out1(true), 0, s(T25')) with rule U4(f271_out1(X33), T24, s(T25)) -> f47_out1(X33) at position [0] and matcher [X33 / true, T24 / 0, T25 / T25'] U6^1(f47_out1(true), 0, s(T25')) -> F48_IN(true, s(T25'), 0) with rule U6^1(f47_out1(T14), T11, T10) -> F48_IN(T14, T10, T11) at position [] and matcher [T14 / true, T11 / 0, T10 / s(T25')] F48_IN(true, s(T25'), 0) -> F383_IN(s(T25'), 0) with rule F48_IN(true, T66, T67) -> F383_IN(T66, T67) at position [] and matcher [T66 / s(T25'), T67 / 0] F383_IN(s(T25'), 0) -> U8^1(f387_in(s(T25'), 0), s(T25'), 0) with rule F383_IN(T66', T67') -> U8^1(f387_in(T66', T67'), T66', T67') at position [] and matcher [T66' / s(T25'), T67' / 0] U8^1(f387_in(s(T25'), 0), s(T25'), 0) -> U8^1(f387_out1(s(T25')), s(T25'), 0) with rule f387_in(T79, 0) -> f387_out1(T79) at position [0] and matcher [T79 / s(T25')] U8^1(f387_out1(s(T25')), s(T25'), 0) -> F1_IN(s(T25'), s(0)) with rule U8^1(f387_out1(T72), T66, T67) -> F1_IN(T72, s(T67)) at position [] and matcher [T72 / s(T25'), T66 / s(T25'), T67 / 0] F1_IN(s(T25'), s(0)) -> F14_IN(0, s(T25')) with rule F1_IN(T10, s(T11)) -> F14_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) PrologToDTProblemTransformerProof (SOUND) Built DT problem from termination graph DT10. { "root": 3, "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": { "49": { "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": [] } }, "type": "Nodes", "350": { "goal": [{ "clause": 0, "scope": 4, "term": "(le T27 T28 X42)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T27", "T28" ], "free": ["X42"], "exprvars": [] } }, "352": { "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": [] } }, "430": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "358": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "92": { "goal": [{ "clause": 6, "scope": 3, "term": "(if (false) (0) (s T15) T10)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": ["T15"], "free": [], "exprvars": [] } }, "51": { "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": [] } }, "96": { "goal": [{ "clause": 7, "scope": 3, "term": "(if (false) (0) (s T15) T10)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": ["T15"], "free": [], "exprvars": [] } }, "10": { "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": [] } }, "55": { "goal": [{ "clause": -1, "scope": -1, "term": "(if (false) (0) (s T15) T10)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": ["T15"], "free": [], "exprvars": [] } }, "58": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "360": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "362": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "363": { "goal": [{ "clause": 1, "scope": 4, "term": "(le T27 T28 X42)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T27", "T28" ], "free": ["X42"], "exprvars": [] } }, "364": { "goal": [{ "clause": 2, "scope": 4, "term": "(le T27 T28 X42)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T27", "T28" ], "free": ["X42"], "exprvars": [] } }, "365": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "3": { "goal": [{ "clause": -1, "scope": -1, "term": "(div T1 T2 T3)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T1", "T2" ], "free": [], "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": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "444": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "6": { "goal": [{ "clause": 5, "scope": 1, "term": "(div T1 T2 T3)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T1", "T2" ], "free": [], "exprvars": [] } }, "7": { "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": [] } }, "8": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "9": { "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": [] } }, "405": { "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": [] } }, "406": { "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": [] } }, "407": { "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": [] } }, "408": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "370": { "goal": [{ "clause": -1, "scope": -1, "term": "(le T48 T49 X68)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T48", "T49" ], "free": ["X68"], "exprvars": [] } }, "371": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "295": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "296": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "297": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "298": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "299": { "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": [] } }, "410": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "411": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "413": { "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": [] } }, "414": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "415": { "goal": [{ "clause": -1, "scope": -1, "term": "(minus (s T72) T73 X95)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T72", "T73" ], "free": ["X95"], "exprvars": [] } }, "416": { "goal": [{ "clause": -1, "scope": -1, "term": "(div T78 (s T73) T75)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T73", "T78" ], "free": [], "exprvars": [] } }, "417": { "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": [] } }, "418": { "goal": [{ "clause": 3, "scope": 6, "term": "(minus (s T72) T73 X95)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T72", "T73" ], "free": ["X95"], "exprvars": [] } }, "419": { "goal": [{ "clause": 4, "scope": 6, "term": "(minus (s T72) T73 X95)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T72", "T73" ], "free": ["X95"], "exprvars": [] } }, "75": { "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": [] } }, "420": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "300": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "421": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "301": { "goal": [{ "clause": -1, "scope": -1, "term": "(le T27 T28 X42)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T27", "T28" ], "free": ["X42"], "exprvars": [] } }, "422": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "302": { "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": [] } }, "423": { "goal": [{ "clause": -1, "scope": -1, "term": "(minus T90 T91 X116)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T90", "T91" ], "free": ["X116"], "exprvars": [] } }, "303": { "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": [] } }, "424": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "425": { "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": [] } }, "426": { "goal": [{ "clause": 3, "scope": 7, "term": "(minus T90 T91 X116)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T90", "T91" ], "free": ["X116"], "exprvars": [] } }, "427": { "goal": [{ "clause": 4, "scope": 7, "term": "(minus T90 T91 X116)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T90", "T91" ], "free": ["X116"], "exprvars": [] } }, "428": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "429": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } } }, "edges": [ { "from": 3, "to": 6, "label": "CASE" }, { "from": 6, "to": 7, "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": 6, "to": 8, "label": "EVAL-BACKTRACK" }, { "from": 7, "to": 9, "label": "CASE" }, { "from": 9, "to": 10, "label": "BACKTRACK\nfor clause: le(0, Y, true)because of non-unification" }, { "from": 10, "to": 49, "label": "PARALLEL" }, { "from": 10, "to": 51, "label": "PARALLEL" }, { "from": 49, "to": 55, "label": "EVAL with clause\nle(s(X13), 0, false).\nand substitutionT8 -> T15,\nX13 -> T15,\nT7 -> 0,\nX7 -> false" }, { "from": 49, "to": 58, "label": "EVAL-BACKTRACK" }, { "from": 51, "to": 299, "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": 51, "to": 300, "label": "EVAL-BACKTRACK" }, { "from": 55, "to": 75, "label": "CASE" }, { "from": 75, "to": 92, "label": "PARALLEL" }, { "from": 75, "to": 96, "label": "PARALLEL" }, { "from": 92, "to": 295, "label": "EVAL with clause\nif(false, X26, s(X27), 0).\nand substitutionX26 -> 0,\nT15 -> T22,\nX27 -> T22,\nT10 -> 0" }, { "from": 92, "to": 296, "label": "EVAL-BACKTRACK" }, { "from": 96, "to": 298, "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": 295, "to": 297, "label": "SUCCESS" }, { "from": 299, "to": 301, "label": "SPLIT 1" }, { "from": 299, "to": 302, "label": "SPLIT 2\nnew knowledge:\nT27 is ground\nT28 is ground\nT31 is ground\nreplacements:X42 -> T31" }, { "from": 301, "to": 303, "label": "CASE" }, { "from": 302, "to": 405, "label": "CASE" }, { "from": 303, "to": 350, "label": "PARALLEL" }, { "from": 303, "to": 352, "label": "PARALLEL" }, { "from": 350, "to": 358, "label": "EVAL with clause\nle(0, X51, true).\nand substitutionT27 -> 0,\nT28 -> T38,\nX51 -> T38,\nX42 -> true" }, { "from": 350, "to": 360, "label": "EVAL-BACKTRACK" }, { "from": 352, "to": 363, "label": "PARALLEL" }, { "from": 352, "to": 364, "label": "PARALLEL" }, { "from": 358, "to": 362, "label": "SUCCESS" }, { "from": 363, "to": 365, "label": "EVAL with clause\nle(s(X56), 0, false).\nand substitutionX56 -> T43,\nT27 -> s(T43),\nT28 -> 0,\nX42 -> false" }, { "from": 363, "to": 366, "label": "EVAL-BACKTRACK" }, { "from": 364, "to": 370, "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": 364, "to": 371, "label": "EVAL-BACKTRACK" }, { "from": 365, "to": 367, "label": "SUCCESS" }, { "from": 370, "to": 301, "label": "INSTANCE with matching:\nT27 -> T48\nT28 -> T49\nX42 -> X68" }, { "from": 405, "to": 406, "label": "PARALLEL" }, { "from": 405, "to": 407, "label": "PARALLEL" }, { "from": 406, "to": 408, "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": 406, "to": 410, "label": "EVAL-BACKTRACK" }, { "from": 407, "to": 413, "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": 407, "to": 414, "label": "EVAL-BACKTRACK" }, { "from": 408, "to": 411, "label": "SUCCESS" }, { "from": 413, "to": 415, "label": "SPLIT 1" }, { "from": 413, "to": 416, "label": "SPLIT 2\nnew knowledge:\nT72 is ground\nT73 is ground\nT78 is ground\nreplacements:X95 -> T78" }, { "from": 415, "to": 417, "label": "CASE" }, { "from": 416, "to": 3, "label": "INSTANCE with matching:\nT1 -> T78\nT2 -> s(T73)\nT3 -> T75" }, { "from": 417, "to": 418, "label": "PARALLEL" }, { "from": 417, "to": 419, "label": "PARALLEL" }, { "from": 418, "to": 420, "label": "EVAL with clause\nminus(X104, 0, X104).\nand substitutionT72 -> T85,\nX104 -> s(T85),\nT73 -> 0,\nX95 -> s(T85)" }, { "from": 418, "to": 421, "label": "EVAL-BACKTRACK" }, { "from": 419, "to": 423, "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": 419, "to": 424, "label": "EVAL-BACKTRACK" }, { "from": 420, "to": 422, "label": "SUCCESS" }, { "from": 423, "to": 425, "label": "CASE" }, { "from": 425, "to": 426, "label": "PARALLEL" }, { "from": 425, "to": 427, "label": "PARALLEL" }, { "from": 426, "to": 428, "label": "EVAL with clause\nminus(X123, 0, X123).\nand substitutionT90 -> T98,\nX123 -> T98,\nT91 -> 0,\nX116 -> T98" }, { "from": 426, "to": 429, "label": "EVAL-BACKTRACK" }, { "from": 427, "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": 427, "to": 444, "label": "EVAL-BACKTRACK" }, { "from": 428, "to": 430, "label": "SUCCESS" }, { "from": 443, "to": 423, "label": "INSTANCE with matching:\nT90 -> T103\nT91 -> T104\nX116 -> X135" } ], "type": "Graph" } } ---------------------------------------- (165) 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) ---------------------------------------- (166) 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 ---------------------------------------- (167) 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 ---------------------------------------- (168) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LOPSTR] contains 3 SCCs with 8 less nodes. ---------------------------------------- (169) Complex Obligation (AND) ---------------------------------------- (170) 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 ---------------------------------------- (171) UsableRulesProof (EQUIVALENT) For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R. ---------------------------------------- (172) 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 ---------------------------------------- (173) PiDPToQDPProof (SOUND) Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi. ---------------------------------------- (174) 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. ---------------------------------------- (175) 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 ---------------------------------------- (176) YES ---------------------------------------- (177) 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 ---------------------------------------- (178) UsableRulesProof (EQUIVALENT) For (infinitary) constructor rewriting [LOPSTR] we can delete all non-usable rules from R. ---------------------------------------- (179) 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 ---------------------------------------- (180) PiDPToQDPProof (SOUND) Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi. ---------------------------------------- (181) 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. ---------------------------------------- (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: *LEA_IN_GGA(s(X1), s(X2)) -> LEA_IN_GGA(X1, X2) The graph contains the following edges 1 > 1, 2 > 2 ---------------------------------------- (183) YES ---------------------------------------- (184) 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 ---------------------------------------- (185) PiDPToQDPProof (SOUND) Transforming (infinitary) constructor rewriting Pi-DP problem [LOPSTR] into ordinary QDP problem [LPAR04] by application of Pi. ---------------------------------------- (186) 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. ---------------------------------------- (187) 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 ---------------------------------------- (188) 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. ---------------------------------------- (189) 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 ---------------------------------------- (190) 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. ---------------------------------------- (191) 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. ---------------------------------------- (192) 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. ---------------------------------------- (193) 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) ---------------------------------------- (194) 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. ---------------------------------------- (195) 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)))) ---------------------------------------- (196) 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. ---------------------------------------- (197) 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. ---------------------------------------- (198) 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. ---------------------------------------- (199) 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) ---------------------------------------- (200) 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. ---------------------------------------- (201) 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))) ---------------------------------------- (202) 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. ---------------------------------------- (203) 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))) ---------------------------------------- (204) 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. ---------------------------------------- (205) 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. ---------------------------------------- (206) 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. ---------------------------------------- (207) 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) ---------------------------------------- (208) 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. ---------------------------------------- (209) 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))) ---------------------------------------- (210) 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. ---------------------------------------- (211) 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. ---------------------------------------- (212) 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. ---------------------------------------- (213) 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) ---------------------------------------- (214) 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. ---------------------------------------- (215) 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. ---------------------------------------- (216) NO ---------------------------------------- (217) PrologToIRSwTTransformerProof (SOUND) Transformed Prolog program to IRSwT according to method in Master Thesis of A. Weinert { "root": 2, "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": { "45": { "goal": [{ "clause": -1, "scope": -1, "term": "(le (s T11) T10 X11)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11" ], "free": ["X11"], "exprvars": [] } }, "46": { "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": [] } }, "290": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "type": "Nodes", "293": { "goal": [{ "clause": -1, "scope": -1, "term": "(le T24 T25 X33)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T24", "T25" ], "free": ["X33"], "exprvars": [] } }, "294": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "372": { "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": [] } }, "394": { "goal": [{ "clause": -1, "scope": -1, "term": "(minus T66 T67 X84)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T66", "T67" ], "free": ["X84"], "exprvars": [] } }, "396": { "goal": [{ "clause": -1, "scope": -1, "term": "(div T72 (s T67) T69)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T67", "T72" ], "free": [], "exprvars": [] } }, "375": { "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": [] } }, "310": { "goal": [{ "clause": 1, "scope": 3, "term": "(le T24 T25 X33)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T24", "T25" ], "free": ["X33"], "exprvars": [] } }, "376": { "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": [] } }, "398": { "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": [] } }, "311": { "goal": [{ "clause": 2, "scope": 3, "term": "(le T24 T25 X33)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T24", "T25" ], "free": ["X33"], "exprvars": [] } }, "312": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "313": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "412": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "314": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "16": { "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": [] } }, "17": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "380": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "282": { "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": [] } }, "381": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "382": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "284": { "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": [] } }, "286": { "goal": [{ "clause": 1, "scope": 2, "term": "(le (s T11) T10 X11)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11" ], "free": ["X11"], "exprvars": [] } }, "385": { "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": [] } }, "287": { "goal": [{ "clause": 2, "scope": 2, "term": "(le (s T11) T10 X11)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T10", "T11" ], "free": ["X11"], "exprvars": [] } }, "386": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "2": { "goal": [{ "clause": -1, "scope": -1, "term": "(div T1 T2 T3)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T1", "T2" ], "free": [], "exprvars": [] } }, "288": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "289": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "4": { "goal": [{ "clause": 5, "scope": 1, "term": "(div T1 T2 T3)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T1", "T2" ], "free": [], "exprvars": [] } }, "400": { "goal": [{ "clause": 3, "scope": 5, "term": "(minus T66 T67 X84)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T66", "T67" ], "free": ["X84"], "exprvars": [] } }, "368": { "goal": [{ "clause": -1, "scope": -1, "term": "(le T42 T43 X57)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T42", "T43" ], "free": ["X57"], "exprvars": [] } }, "401": { "goal": [{ "clause": 4, "scope": 5, "term": "(minus T66 T67 X84)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T66", "T67" ], "free": ["X84"], "exprvars": [] } }, "369": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "402": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "304": { "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": [] } }, "403": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "305": { "goal": [{ "clause": 0, "scope": 3, "term": "(le T24 T25 X33)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T24", "T25" ], "free": ["X33"], "exprvars": [] } }, "404": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "306": { "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": [] } }, "307": { "goal": [{ "clause": -1, "scope": -1, "term": "(true)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "308": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "309": { "goal": [], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [], "free": [], "exprvars": [] } }, "409": { "goal": [{ "clause": -1, "scope": -1, "term": "(minus T84 T85 X105)" }], "kb": { "nonunifying": [], "intvars": {}, "arithmetic": { "type": "PlainIntegerRelationState", "relations": [] }, "ground": [ "T84", "T85" ], "free": ["X105"], "exprvars": [] } } }, "edges": [ { "from": 2, "to": 4, "label": "CASE" }, { "from": 4, "to": 16, "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": 4, "to": 17, "label": "EVAL-BACKTRACK" }, { "from": 16, "to": 45, "label": "SPLIT 1" }, { "from": 16, "to": 46, "label": "SPLIT 2\nnew knowledge:\nT11 is ground\nT10 is ground\nT14 is ground\nreplacements:X11 -> T14" }, { "from": 45, "to": 282, "label": "CASE" }, { "from": 46, "to": 372, "label": "CASE" }, { "from": 282, "to": 284, "label": "BACKTRACK\nfor clause: le(0, Y, true)because of non-unification" }, { "from": 284, "to": 286, "label": "PARALLEL" }, { "from": 284, "to": 287, "label": "PARALLEL" }, { "from": 286, "to": 288, "label": "EVAL with clause\nle(s(X21), 0, false).\nand substitutionT11 -> T19,\nX21 -> T19,\nT10 -> 0,\nX11 -> false" }, { "from": 286, "to": 289, "label": "EVAL-BACKTRACK" }, { "from": 287, "to": 293, "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": 287, "to": 294, "label": "EVAL-BACKTRACK" }, { "from": 288, "to": 290, "label": "SUCCESS" }, { "from": 293, "to": 304, "label": "CASE" }, { "from": 304, "to": 305, "label": "PARALLEL" }, { "from": 304, "to": 306, "label": "PARALLEL" }, { "from": 305, "to": 307, "label": "EVAL with clause\nle(0, X40, true).\nand substitutionT24 -> 0,\nT25 -> T32,\nX40 -> T32,\nX33 -> true" }, { "from": 305, "to": 308, "label": "EVAL-BACKTRACK" }, { "from": 306, "to": 310, "label": "PARALLEL" }, { "from": 306, "to": 311, "label": "PARALLEL" }, { "from": 307, "to": 309, "label": "SUCCESS" }, { "from": 310, "to": 312, "label": "EVAL with clause\nle(s(X45), 0, false).\nand substitutionX45 -> T37,\nT24 -> s(T37),\nT25 -> 0,\nX33 -> false" }, { "from": 310, "to": 313, "label": "EVAL-BACKTRACK" }, { "from": 311, "to": 368, "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": 311, "to": 369, "label": "EVAL-BACKTRACK" }, { "from": 312, "to": 314, "label": "SUCCESS" }, { "from": 368, "to": 293, "label": "INSTANCE with matching:\nT24 -> T42\nT25 -> T43\nX33 -> X57" }, { "from": 372, "to": 375, "label": "PARALLEL" }, { "from": 372, "to": 376, "label": "PARALLEL" }, { "from": 375, "to": 380, "label": "EVAL with clause\nif(false, X72, s(X73), 0).\nand substitutionT14 -> false,\nT10 -> T58,\nX72 -> T58,\nT11 -> T59,\nX73 -> T59,\nT13 -> 0" }, { "from": 375, "to": 381, "label": "EVAL-BACKTRACK" }, { "from": 376, "to": 385, "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": 376, "to": 386, "label": "EVAL-BACKTRACK" }, { "from": 380, "to": 382, "label": "SUCCESS" }, { "from": 385, "to": 394, "label": "SPLIT 1" }, { "from": 385, "to": 396, "label": "SPLIT 2\nnew knowledge:\nT66 is ground\nT67 is ground\nT72 is ground\nreplacements:X84 -> T72" }, { "from": 394, "to": 398, "label": "CASE" }, { "from": 396, "to": 2, "label": "INSTANCE with matching:\nT1 -> T72\nT2 -> s(T67)\nT3 -> T69" }, { "from": 398, "to": 400, "label": "PARALLEL" }, { "from": 398, "to": 401, "label": "PARALLEL" }, { "from": 400, "to": 402, "label": "EVAL with clause\nminus(X93, 0, X93).\nand substitutionT66 -> T79,\nX93 -> T79,\nT67 -> 0,\nX84 -> T79" }, { "from": 400, "to": 403, "label": "EVAL-BACKTRACK" }, { "from": 401, "to": 409, "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": 401, "to": 412, "label": "EVAL-BACKTRACK" }, { "from": 402, "to": 404, "label": "SUCCESS" }, { "from": 409, "to": 394, "label": "INSTANCE with matching:\nT66 -> T84\nT67 -> T85\nX84 -> X105" } ], "type": "Graph" } } ---------------------------------------- (218) Complex Obligation (AND) ---------------------------------------- (219) Obligation: Rules: f400_out(T66, T67) -> f398_out(T66, T67) :|: TRUE f401_out(x, x1) -> f398_out(x, x1) :|: TRUE f398_in(x2, x3) -> f401_in(x2, x3) :|: TRUE f398_in(x4, x5) -> f400_in(x4, x5) :|: TRUE f409_in(T84, T85) -> f394_in(T84, T85) :|: TRUE f394_out(x6, x7) -> f409_out(x6, x7) :|: TRUE f401_in(s(x8), s(x9)) -> f409_in(x8, x9) :|: TRUE f401_in(x10, x11) -> f412_in :|: TRUE f412_out -> f401_out(x12, x13) :|: TRUE f409_out(x14, x15) -> f401_out(s(x14), s(x15)) :|: TRUE f394_in(x16, x17) -> f398_in(x16, x17) :|: TRUE f398_out(x18, x19) -> f394_out(x18, x19) :|: TRUE f2_in(T1, T2) -> f4_in(T1, T2) :|: TRUE f4_out(x20, x21) -> f2_out(x20, x21) :|: TRUE f17_out -> f4_out(x22, x23) :|: TRUE f4_in(T10, s(T11)) -> f16_in(T11, T10) :|: TRUE f16_out(x24, x25) -> f4_out(x25, s(x24)) :|: TRUE f4_in(x26, x27) -> f17_in :|: TRUE f16_in(x28, x29) -> f45_in(x28, x29) :|: TRUE f45_out(x30, x31) -> f46_in(x32, x31, x30) :|: TRUE f46_out(x33, x34, x35) -> f16_out(x35, x34) :|: TRUE f372_out(x36, x37, x38) -> f46_out(x36, x37, x38) :|: TRUE f46_in(x39, x40, x41) -> f372_in(x39, x40, x41) :|: TRUE f376_out(x42, x43, x44) -> f372_out(x42, x43, x44) :|: TRUE f372_in(x45, x46, x47) -> f375_in(x45, x46, x47) :|: TRUE f375_out(x48, x49, x50) -> f372_out(x48, x49, x50) :|: TRUE f372_in(x51, x52, x53) -> f376_in(x51, x52, x53) :|: TRUE f376_in(x54, x55, x56) -> f386_in :|: TRUE f386_out -> f376_out(x57, x58, x59) :|: TRUE f376_in(true, x60, x61) -> f385_in(x60, x61) :|: TRUE f385_out(x62, x63) -> f376_out(true, x62, x63) :|: TRUE f394_out(x64, x65) -> f396_in(x66, x65) :|: TRUE f385_in(x67, x68) -> f394_in(x67, x68) :|: TRUE f396_out(x69, x70) -> f385_out(x71, x70) :|: TRUE Start term: f2_in(T1, T2) ---------------------------------------- (220) IRSwTSimpleDependencyGraphProof (EQUIVALENT) Constructed simple dependency graph. Simplified to the following IRSwTs: ---------------------------------------- (221) TRUE ---------------------------------------- (222) Obligation: Rules: f311_in(T24, T25) -> f369_in :|: TRUE f311_in(s(T42), s(T43)) -> f368_in(T42, T43) :|: TRUE f368_out(x, x1) -> f311_out(s(x), s(x1)) :|: TRUE f369_out -> f311_out(x2, x3) :|: TRUE f293_out(x4, x5) -> f368_out(x4, x5) :|: TRUE f368_in(x6, x7) -> f293_in(x6, x7) :|: TRUE f293_in(x8, x9) -> f304_in(x8, x9) :|: TRUE f304_out(x10, x11) -> f293_out(x10, x11) :|: TRUE f310_out(x12, x13) -> f306_out(x12, x13) :|: TRUE f306_in(x14, x15) -> f311_in(x14, x15) :|: TRUE f306_in(x16, x17) -> f310_in(x16, x17) :|: TRUE f311_out(x18, x19) -> f306_out(x18, x19) :|: TRUE f304_in(x20, x21) -> f305_in(x20, x21) :|: TRUE f305_out(x22, x23) -> f304_out(x22, x23) :|: TRUE f306_out(x24, x25) -> f304_out(x24, x25) :|: TRUE f304_in(x26, x27) -> f306_in(x26, x27) :|: TRUE f2_in(T1, T2) -> f4_in(T1, T2) :|: TRUE f4_out(x28, x29) -> f2_out(x28, x29) :|: TRUE f17_out -> f4_out(x30, x31) :|: TRUE f4_in(T10, s(T11)) -> f16_in(T11, T10) :|: TRUE f16_out(x32, x33) -> f4_out(x33, s(x32)) :|: TRUE f4_in(x34, x35) -> f17_in :|: TRUE f16_in(x36, x37) -> f45_in(x36, x37) :|: TRUE f45_out(x38, x39) -> f46_in(x40, x39, x38) :|: TRUE f46_out(x41, x42, x43) -> f16_out(x43, x42) :|: TRUE f45_in(x44, x45) -> f282_in(x44, x45) :|: TRUE f282_out(x46, x47) -> f45_out(x46, x47) :|: TRUE f284_out(x48, x49) -> f282_out(x48, x49) :|: TRUE f282_in(x50, x51) -> f284_in(x50, x51) :|: TRUE f287_out(x52, x53) -> f284_out(x52, x53) :|: TRUE f284_in(x54, x55) -> f286_in(x54, x55) :|: TRUE f286_out(x56, x57) -> f284_out(x56, x57) :|: TRUE f284_in(x58, x59) -> f287_in(x58, x59) :|: TRUE f293_out(x60, x61) -> f287_out(x60, s(x61)) :|: TRUE f287_in(x62, s(x63)) -> f293_in(x62, x63) :|: TRUE f287_in(x64, x65) -> f294_in :|: TRUE f294_out -> f287_out(x66, x67) :|: TRUE Start term: f2_in(T1, T2) ---------------------------------------- (223) IRSwTSimpleDependencyGraphProof (EQUIVALENT) Constructed simple dependency graph. Simplified to the following IRSwTs: intTRSProblem: f311_in(s(T42), s(T43)) -> f368_in(T42, T43) :|: TRUE f368_in(x6, x7) -> f293_in(x6, x7) :|: TRUE f293_in(x8, x9) -> f304_in(x8, x9) :|: TRUE f306_in(x14, x15) -> f311_in(x14, x15) :|: TRUE f304_in(x26, x27) -> f306_in(x26, x27) :|: TRUE ---------------------------------------- (224) Obligation: Rules: f311_in(s(T42), s(T43)) -> f368_in(T42, T43) :|: TRUE f368_in(x6, x7) -> f293_in(x6, x7) :|: TRUE f293_in(x8, x9) -> f304_in(x8, x9) :|: TRUE f306_in(x14, x15) -> f311_in(x14, x15) :|: TRUE f304_in(x26, x27) -> f306_in(x26, x27) :|: TRUE ---------------------------------------- (225) IntTRSCompressionProof (EQUIVALENT) Compressed rules. ---------------------------------------- (226) Obligation: Rules: f306_in(s(T42:0), s(T43:0)) -> f306_in(T42:0, T43:0) :|: TRUE ---------------------------------------- (227) IRSFormatTransformerProof (EQUIVALENT) Reformatted IRS to match normalized format (transformed away non-linear left-hand sides, !=, / and %). ---------------------------------------- (228) Obligation: Rules: f306_in(s(T42:0), s(T43:0)) -> f306_in(T42:0, T43:0) :|: TRUE ---------------------------------------- (229) IRSwTTerminationDigraphProof (EQUIVALENT) Constructed termination digraph! Nodes: (1) f306_in(s(T42:0), s(T43:0)) -> f306_in(T42:0, T43:0) :|: TRUE Arcs: (1) -> (1) This digraph is fully evaluated! ---------------------------------------- (230) Obligation: Termination digraph: Nodes: (1) f306_in(s(T42:0), s(T43:0)) -> f306_in(T42:0, T43:0) :|: TRUE Arcs: (1) -> (1) This digraph is fully evaluated! ---------------------------------------- (231) TempFilterProof (SOUND) Used the following sort dictionary for filtering: f306_in(VARIABLE, VARIABLE) s(VARIABLE) Removed predefined arithmetic. ---------------------------------------- (232) Obligation: Rules: f306_in(s(T42:0), s(T43:0)) -> f306_in(T42:0, T43:0) ---------------------------------------- (233) IRSwTToQDPProof (SOUND) Removed the integers and created a QDP-Problem. ---------------------------------------- (234) Obligation: Q DP problem: The TRS P consists of the following rules: f306_in(s(T42:0), s(T43:0)) -> f306_in(T42:0, T43:0) R is empty. Q is empty. We have to consider all (P,Q,R)-chains. ---------------------------------------- (235) 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: *f306_in(s(T42:0), s(T43:0)) -> f306_in(T42:0, T43:0) The graph contains the following edges 1 > 1, 2 > 2 ---------------------------------------- (236) YES ---------------------------------------- (237) Obligation: Rules: f284_out(T11, T10) -> f282_out(T11, T10) :|: TRUE f282_in(x, x1) -> f284_in(x, x1) :|: TRUE f409_in(T84, T85) -> f394_in(T84, T85) :|: TRUE f394_out(x2, x3) -> f409_out(x2, x3) :|: TRUE f2_out(T72, s(T67)) -> f396_out(T72, T67) :|: TRUE f396_in(x4, x5) -> f2_in(x4, s(x5)) :|: TRUE f16_in(x6, x7) -> f45_in(x6, x7) :|: TRUE f45_out(x8, x9) -> f46_in(x10, x9, x8) :|: TRUE f46_out(x11, x12, x13) -> f16_out(x13, x12) :|: TRUE f2_in(T1, T2) -> f4_in(T1, T2) :|: TRUE f4_out(x14, x15) -> f2_out(x14, x15) :|: TRUE f402_in -> f402_out :|: TRUE f308_out -> f305_out(T24, T25) :|: TRUE f305_in(0, T32) -> f307_in :|: TRUE f305_in(x16, x17) -> f308_in :|: TRUE f307_out -> f305_out(0, x18) :|: TRUE f293_in(x19, x20) -> f304_in(x19, x20) :|: TRUE f304_out(x21, x22) -> f293_out(x21, x22) :|: TRUE f287_out(x23, x24) -> f284_out(x23, x24) :|: TRUE f284_in(x25, x26) -> f286_in(x25, x26) :|: TRUE f286_out(x27, x28) -> f284_out(x27, x28) :|: TRUE f284_in(x29, x30) -> f287_in(x29, x30) :|: TRUE f307_in -> f307_out :|: TRUE f394_out(x31, x32) -> f396_in(x33, x32) :|: TRUE f385_in(x34, x35) -> f394_in(x34, x35) :|: TRUE f396_out(x36, x37) -> f385_out(x38, x37) :|: TRUE f310_out(x39, x40) -> f306_out(x39, x40) :|: TRUE f306_in(x41, x42) -> f311_in(x41, x42) :|: TRUE f306_in(x43, x44) -> f310_in(x43, x44) :|: TRUE f311_out(x45, x46) -> f306_out(x45, x46) :|: TRUE f293_out(x47, x48) -> f287_out(x47, s(x48)) :|: TRUE f287_in(x49, s(x50)) -> f293_in(x49, x50) :|: TRUE f287_in(x51, x52) -> f294_in :|: TRUE f294_out -> f287_out(x53, x54) :|: TRUE f45_in(x55, x56) -> f282_in(x55, x56) :|: TRUE f282_out(x57, x58) -> f45_out(x57, x58) :|: TRUE f304_in(x59, x60) -> f305_in(x59, x60) :|: TRUE f305_out(x61, x62) -> f304_out(x61, x62) :|: TRUE f306_out(x63, x64) -> f304_out(x63, x64) :|: TRUE f304_in(x65, x66) -> f306_in(x65, x66) :|: TRUE f286_in(x67, x68) -> f289_in :|: TRUE f288_out -> f286_out(T19, 0) :|: TRUE f289_out -> f286_out(x69, x70) :|: TRUE f286_in(x71, 0) -> f288_in :|: TRUE f311_in(x72, x73) -> f369_in :|: TRUE f311_in(s(T42), s(T43)) -> f368_in(T42, T43) :|: TRUE f368_out(x74, x75) -> f311_out(s(x74), s(x75)) :|: TRUE f369_out -> f311_out(x76, x77) :|: TRUE f376_in(x78, x79, x80) -> f386_in :|: TRUE f386_out -> f376_out(x81, x82, x83) :|: TRUE f376_in(true, x84, x85) -> f385_in(x84, x85) :|: TRUE f385_out(x86, x87) -> f376_out(true, x86, x87) :|: TRUE f312_in -> f312_out :|: TRUE f288_in -> f288_out :|: TRUE f312_out -> f310_out(s(T37), 0) :|: TRUE f313_out -> f310_out(x88, x89) :|: TRUE f310_in(x90, x91) -> f313_in :|: TRUE f310_in(s(x92), 0) -> f312_in :|: TRUE f401_in(s(x93), s(x94)) -> f409_in(x93, x94) :|: TRUE f401_in(x95, x96) -> f412_in :|: TRUE f412_out -> f401_out(x97, x98) :|: TRUE f409_out(x99, x100) -> f401_out(s(x99), s(x100)) :|: TRUE f394_in(x101, x102) -> f398_in(x101, x102) :|: TRUE f398_out(x103, x104) -> f394_out(x103, x104) :|: TRUE f372_out(x105, x106, x107) -> f46_out(x105, x106, x107) :|: TRUE f46_in(x108, x109, x110) -> f372_in(x108, x109, x110) :|: TRUE f293_out(x111, x112) -> f368_out(x111, x112) :|: TRUE f368_in(x113, x114) -> f293_in(x113, x114) :|: TRUE f400_out(x115, x116) -> f398_out(x115, x116) :|: TRUE f401_out(x117, x118) -> f398_out(x117, x118) :|: TRUE f398_in(x119, x120) -> f401_in(x119, x120) :|: TRUE f398_in(x121, x122) -> f400_in(x121, x122) :|: TRUE f403_out -> f400_out(x123, x124) :|: TRUE f400_in(x125, x126) -> f403_in :|: TRUE f402_out -> f400_out(T79, 0) :|: TRUE f400_in(x127, 0) -> f402_in :|: TRUE f17_out -> f4_out(x128, x129) :|: TRUE f4_in(x130, s(x131)) -> f16_in(x131, x130) :|: TRUE f16_out(x132, x133) -> f4_out(x133, s(x132)) :|: TRUE f4_in(x134, x135) -> f17_in :|: TRUE f376_out(x136, x137, x138) -> f372_out(x136, x137, x138) :|: TRUE f372_in(x139, x140, x141) -> f375_in(x139, x140, x141) :|: TRUE f375_out(x142, x143, x144) -> f372_out(x142, x143, x144) :|: TRUE f372_in(x145, x146, x147) -> f376_in(x145, x146, x147) :|: TRUE Start term: f2_in(T1, T2) ---------------------------------------- (238) IRSwTSimpleDependencyGraphProof (EQUIVALENT) Constructed simple dependency graph. Simplified to the following IRSwTs: intTRSProblem: f284_out(T11, T10) -> f282_out(T11, T10) :|: TRUE f282_in(x, x1) -> f284_in(x, x1) :|: TRUE f409_in(T84, T85) -> f394_in(T84, T85) :|: TRUE f394_out(x2, x3) -> f409_out(x2, x3) :|: TRUE f396_in(x4, x5) -> f2_in(x4, s(x5)) :|: TRUE f16_in(x6, x7) -> f45_in(x6, x7) :|: TRUE f45_out(x8, x9) -> f46_in(x10, x9, x8) :|: TRUE f2_in(T1, T2) -> f4_in(T1, T2) :|: TRUE f402_in -> f402_out :|: TRUE f305_in(0, T32) -> f307_in :|: TRUE f307_out -> f305_out(0, x18) :|: TRUE f293_in(x19, x20) -> f304_in(x19, x20) :|: TRUE f304_out(x21, x22) -> f293_out(x21, x22) :|: TRUE f287_out(x23, x24) -> f284_out(x23, x24) :|: TRUE f284_in(x25, x26) -> f286_in(x25, x26) :|: TRUE f286_out(x27, x28) -> f284_out(x27, x28) :|: TRUE f284_in(x29, x30) -> f287_in(x29, x30) :|: TRUE f307_in -> f307_out :|: TRUE f394_out(x31, x32) -> f396_in(x33, x32) :|: TRUE f385_in(x34, x35) -> f394_in(x34, x35) :|: TRUE f310_out(x39, x40) -> f306_out(x39, x40) :|: TRUE f306_in(x41, x42) -> f311_in(x41, x42) :|: TRUE f306_in(x43, x44) -> f310_in(x43, x44) :|: TRUE f311_out(x45, x46) -> f306_out(x45, x46) :|: TRUE f293_out(x47, x48) -> f287_out(x47, s(x48)) :|: TRUE f287_in(x49, s(x50)) -> f293_in(x49, x50) :|: TRUE f45_in(x55, x56) -> f282_in(x55, x56) :|: TRUE f282_out(x57, x58) -> f45_out(x57, x58) :|: TRUE f304_in(x59, x60) -> f305_in(x59, x60) :|: TRUE f305_out(x61, x62) -> f304_out(x61, x62) :|: TRUE f306_out(x63, x64) -> f304_out(x63, x64) :|: TRUE f304_in(x65, x66) -> f306_in(x65, x66) :|: TRUE f288_out -> f286_out(T19, 0) :|: TRUE f286_in(x71, 0) -> f288_in :|: TRUE f311_in(s(T42), s(T43)) -> f368_in(T42, T43) :|: TRUE f368_out(x74, x75) -> f311_out(s(x74), s(x75)) :|: TRUE f376_in(true, x84, x85) -> f385_in(x84, x85) :|: TRUE f312_in -> f312_out :|: TRUE f288_in -> f288_out :|: TRUE f312_out -> f310_out(s(T37), 0) :|: TRUE f310_in(s(x92), 0) -> f312_in :|: TRUE f401_in(s(x93), s(x94)) -> f409_in(x93, x94) :|: TRUE f409_out(x99, x100) -> f401_out(s(x99), s(x100)) :|: TRUE f394_in(x101, x102) -> f398_in(x101, x102) :|: TRUE f398_out(x103, x104) -> f394_out(x103, x104) :|: TRUE f46_in(x108, x109, x110) -> f372_in(x108, x109, x110) :|: TRUE f293_out(x111, x112) -> f368_out(x111, x112) :|: TRUE f368_in(x113, x114) -> f293_in(x113, x114) :|: TRUE f400_out(x115, x116) -> f398_out(x115, x116) :|: TRUE f401_out(x117, x118) -> f398_out(x117, x118) :|: TRUE f398_in(x119, x120) -> f401_in(x119, x120) :|: TRUE f398_in(x121, x122) -> f400_in(x121, x122) :|: TRUE f402_out -> f400_out(T79, 0) :|: TRUE f400_in(x127, 0) -> f402_in :|: TRUE f4_in(x130, s(x131)) -> f16_in(x131, x130) :|: TRUE f372_in(x145, x146, x147) -> f376_in(x145, x146, x147) :|: TRUE ---------------------------------------- (239) Obligation: Rules: f284_out(T11, T10) -> f282_out(T11, T10) :|: TRUE f282_in(x, x1) -> f284_in(x, x1) :|: TRUE f409_in(T84, T85) -> f394_in(T84, T85) :|: TRUE f394_out(x2, x3) -> f409_out(x2, x3) :|: TRUE f396_in(x4, x5) -> f2_in(x4, s(x5)) :|: TRUE f16_in(x6, x7) -> f45_in(x6, x7) :|: TRUE f45_out(x8, x9) -> f46_in(x10, x9, x8) :|: TRUE f2_in(T1, T2) -> f4_in(T1, T2) :|: TRUE f402_in -> f402_out :|: TRUE f305_in(0, T32) -> f307_in :|: TRUE f307_out -> f305_out(0, x18) :|: TRUE f293_in(x19, x20) -> f304_in(x19, x20) :|: TRUE f304_out(x21, x22) -> f293_out(x21, x22) :|: TRUE f287_out(x23, x24) -> f284_out(x23, x24) :|: TRUE f284_in(x25, x26) -> f286_in(x25, x26) :|: TRUE f286_out(x27, x28) -> f284_out(x27, x28) :|: TRUE f284_in(x29, x30) -> f287_in(x29, x30) :|: TRUE f307_in -> f307_out :|: TRUE f394_out(x31, x32) -> f396_in(x33, x32) :|: TRUE f385_in(x34, x35) -> f394_in(x34, x35) :|: TRUE f310_out(x39, x40) -> f306_out(x39, x40) :|: TRUE f306_in(x41, x42) -> f311_in(x41, x42) :|: TRUE f306_in(x43, x44) -> f310_in(x43, x44) :|: TRUE f311_out(x45, x46) -> f306_out(x45, x46) :|: TRUE f293_out(x47, x48) -> f287_out(x47, s(x48)) :|: TRUE f287_in(x49, s(x50)) -> f293_in(x49, x50) :|: TRUE f45_in(x55, x56) -> f282_in(x55, x56) :|: TRUE f282_out(x57, x58) -> f45_out(x57, x58) :|: TRUE f304_in(x59, x60) -> f305_in(x59, x60) :|: TRUE f305_out(x61, x62) -> f304_out(x61, x62) :|: TRUE f306_out(x63, x64) -> f304_out(x63, x64) :|: TRUE f304_in(x65, x66) -> f306_in(x65, x66) :|: TRUE f288_out -> f286_out(T19, 0) :|: TRUE f286_in(x71, 0) -> f288_in :|: TRUE f311_in(s(T42), s(T43)) -> f368_in(T42, T43) :|: TRUE f368_out(x74, x75) -> f311_out(s(x74), s(x75)) :|: TRUE f376_in(true, x84, x85) -> f385_in(x84, x85) :|: TRUE f312_in -> f312_out :|: TRUE f288_in -> f288_out :|: TRUE f312_out -> f310_out(s(T37), 0) :|: TRUE f310_in(s(x92), 0) -> f312_in :|: TRUE f401_in(s(x93), s(x94)) -> f409_in(x93, x94) :|: TRUE f409_out(x99, x100) -> f401_out(s(x99), s(x100)) :|: TRUE f394_in(x101, x102) -> f398_in(x101, x102) :|: TRUE f398_out(x103, x104) -> f394_out(x103, x104) :|: TRUE f46_in(x108, x109, x110) -> f372_in(x108, x109, x110) :|: TRUE f293_out(x111, x112) -> f368_out(x111, x112) :|: TRUE f368_in(x113, x114) -> f293_in(x113, x114) :|: TRUE f400_out(x115, x116) -> f398_out(x115, x116) :|: TRUE f401_out(x117, x118) -> f398_out(x117, x118) :|: TRUE f398_in(x119, x120) -> f401_in(x119, x120) :|: TRUE f398_in(x121, x122) -> f400_in(x121, x122) :|: TRUE f402_out -> f400_out(T79, 0) :|: TRUE f400_in(x127, 0) -> f402_in :|: TRUE f4_in(x130, s(x131)) -> f16_in(x131, x130) :|: TRUE f372_in(x145, x146, x147) -> f376_in(x145, x146, x147) :|: TRUE ---------------------------------------- (240) IntTRSCompressionProof (EQUIVALENT) Compressed rules. ---------------------------------------- (241) Obligation: Rules: f293_in(cons_0, x20:0) -> f304_out(0, x18:0) :|: TRUE && cons_0 = 0 f293_in(s(x), x1) -> f304_out(s(x2), 0) :|: TRUE && x1 = 0 f398_in(x3, x4) -> f398_out(x5, 0) :|: TRUE && x4 = 0 f304_out(x21:0, x22:0) -> f398_in(s(x22:0), x21:0) :|: TRUE f398_out(x103:0, x104:0) -> f398_in(0, T19:0) :|: TRUE f304_out(x6, x7) -> f304_out(s(x6), s(x7)) :|: TRUE f398_out(x8, x9) -> f293_in(x9, x10) :|: TRUE f293_in(s(T42:0), s(T43:0)) -> f293_in(T42:0, T43:0) :|: TRUE f398_out(x11, x12) -> f398_out(s(x11), s(x12)) :|: TRUE f398_in(s(x93:0), s(x94:0)) -> f398_in(x93:0, x94:0) :|: TRUE ---------------------------------------- (242) IRSFormatTransformerProof (EQUIVALENT) Reformatted IRS to match normalized format (transformed away non-linear left-hand sides, !=, / and %). ---------------------------------------- (243) Obligation: Rules: f293_in(cons_0, x20:0) -> f304_out(0, x18:0) :|: TRUE && cons_0 = 0 f293_in(s(x), x1) -> f304_out(s(x2), 0) :|: TRUE && x1 = 0 f398_in(x3, x4) -> f398_out(x5, 0) :|: TRUE && x4 = 0 f304_out(x21:0, x22:0) -> f398_in(s(x22:0), x21:0) :|: TRUE f398_out(x103:0, x104:0) -> f398_in(0, T19:0) :|: TRUE f304_out(x6, x7) -> f304_out(s(x6), s(x7)) :|: TRUE f398_out(x8, x9) -> f293_in(x9, x10) :|: TRUE f293_in(s(T42:0), s(T43:0)) -> f293_in(T42:0, T43:0) :|: TRUE f398_out(x11, x12) -> f398_out(s(x11), s(x12)) :|: TRUE f398_in(s(x93:0), s(x94:0)) -> f398_in(x93:0, x94:0) :|: TRUE ---------------------------------------- (244) IRSwTTerminationDigraphProof (EQUIVALENT) Constructed termination digraph! Nodes: (1) f293_in(cons_0, x20:0) -> f304_out(0, x18:0) :|: TRUE && cons_0 = 0 (2) f293_in(s(x), x1) -> f304_out(s(x2), 0) :|: TRUE && x1 = 0 (3) f398_in(x3, x4) -> f398_out(x5, 0) :|: TRUE && x4 = 0 (4) f304_out(x21:0, x22:0) -> f398_in(s(x22:0), x21:0) :|: TRUE (5) f398_out(x103:0, x104:0) -> f398_in(0, T19:0) :|: TRUE (6) f304_out(x6, x7) -> f304_out(s(x6), s(x7)) :|: TRUE (7) f398_out(x8, x9) -> f293_in(x9, x10) :|: TRUE (8) f293_in(s(T42:0), s(T43:0)) -> f293_in(T42:0, T43:0) :|: TRUE (9) f398_out(x11, x12) -> f398_out(s(x11), s(x12)) :|: TRUE (10) f398_in(s(x93:0), s(x94:0)) -> f398_in(x93:0, x94:0) :|: TRUE Arcs: (1) -> (4), (6) (2) -> (4), (6) (3) -> (5), (7), (9) (4) -> (3), (10) (5) -> (3) (6) -> (4), (6) (7) -> (1), (2), (8) (8) -> (1), (2), (8) (9) -> (5), (7), (9) (10) -> (3), (10) This digraph is fully evaluated! ---------------------------------------- (245) Obligation: Termination digraph: Nodes: (1) f293_in(cons_0, x20:0) -> f304_out(0, x18:0) :|: TRUE && cons_0 = 0 (2) f398_out(x8, x9) -> f293_in(x9, x10) :|: TRUE (3) f398_in(x3, x4) -> f398_out(x5, 0) :|: TRUE && x4 = 0 (4) f398_in(s(x93:0), s(x94:0)) -> f398_in(x93:0, x94:0) :|: TRUE (5) f398_out(x103:0, x104:0) -> f398_in(0, T19:0) :|: TRUE (6) f398_out(x11, x12) -> f398_out(s(x11), s(x12)) :|: TRUE (7) f304_out(x21:0, x22:0) -> f398_in(s(x22:0), x21:0) :|: TRUE (8) f304_out(x6, x7) -> f304_out(s(x6), s(x7)) :|: TRUE (9) f293_in(s(x), x1) -> f304_out(s(x2), 0) :|: TRUE && x1 = 0 (10) f293_in(s(T42:0), s(T43:0)) -> f293_in(T42:0, T43:0) :|: TRUE Arcs: (1) -> (7), (8) (2) -> (1), (9), (10) (3) -> (2), (5), (6) (4) -> (3), (4) (5) -> (3) (6) -> (2), (5), (6) (7) -> (3), (4) (8) -> (7), (8) (9) -> (7), (8) (10) -> (1), (9), (10) This digraph is fully evaluated! ---------------------------------------- (246) IntTRSCompressionProof (EQUIVALENT) Compressed rules. ---------------------------------------- (247) Obligation: Rules: f293_in(cons_0, x20:0:0) -> f304_out(0, x18:0:0) :|: TRUE && cons_0 = 0 f293_in(s(T42:0:0), s(T43:0:0)) -> f293_in(T42:0:0, T43:0:0) :|: TRUE f304_out(x6:0, x7:0) -> f304_out(s(x6:0), s(x7:0)) :|: TRUE f293_in(s(x), x1) -> f304_out(s(x2), 0) :|: TRUE && x1 = 0 f398_out(x8:0, x9:0) -> f293_in(x9:0, x10:0) :|: TRUE f398_in(s(x93:0:0), s(x94:0:0)) -> f398_in(x93:0:0, x94:0:0) :|: TRUE f398_out(x11:0, x12:0) -> f398_out(s(x11:0), s(x12:0)) :|: TRUE f304_out(x21:0:0, x22:0:0) -> f398_in(s(x22:0:0), x21:0:0) :|: TRUE f398_out(x103:0:0, x104:0:0) -> f398_in(0, T19:0:0) :|: TRUE f398_in(x3, x4) -> f398_out(x5, 0) :|: TRUE && x4 = 0 ---------------------------------------- (248) IntTRSUnneededArgumentFilterProof (EQUIVALENT) Some arguments are removed because they cannot influence termination. We removed arguments according to the following replacements: f398_out(x1, x2) -> f398_out(x2) ---------------------------------------- (249) Obligation: Rules: f293_in(cons_0, x20:0:0) -> f304_out(0, x18:0:0) :|: TRUE && cons_0 = 0 f293_in(s(T42:0:0), s(T43:0:0)) -> f293_in(T42:0:0, T43:0:0) :|: TRUE f304_out(x6:0, x7:0) -> f304_out(s(x6:0), s(x7:0)) :|: TRUE f293_in(s(x), x1) -> f304_out(s(x2), 0) :|: TRUE && x1 = 0 f398_out(x9:0) -> f293_in(x9:0, x10:0) :|: TRUE f398_in(s(x93:0:0), s(x94:0:0)) -> f398_in(x93:0:0, x94:0:0) :|: TRUE f398_out(x12:0) -> f398_out(s(x12:0)) :|: TRUE f304_out(x21:0:0, x22:0:0) -> f398_in(s(x22:0:0), x21:0:0) :|: TRUE f398_out(x104:0:0) -> f398_in(0, T19:0:0) :|: TRUE f398_in(x3, x4) -> f398_out(0) :|: TRUE && x4 = 0 ---------------------------------------- (250) IRSwTToIntTRSProof (SOUND) Applied path-length measure to transform intTRS with terms to intTRS. ---------------------------------------- (251) Obligation: Rules: f293_in(cons_0, x1) -> f304_out(0, x2) :|: TRUE && cons_0 = 0 f293_in(s(x3), s(x4)) -> f293_in(x3, x4) :|: TRUE f304_out(x5, x6) -> f304_out(s(x5), s(x6)) :|: TRUE f293_in(s(x), x8) -> f304_out(s(x20), 0) :|: TRUE && x8 = 0 f398_out(x10) -> f293_in(x10, x11) :|: TRUE f398_in(s(x12), s(x13)) -> f398_in(x12, x13) :|: TRUE f398_out(x14) -> f398_out(s(x14)) :|: TRUE f304_out(x15, x16) -> f398_in(s(x16), x15) :|: TRUE f398_out(x17) -> f398_in(0, x18) :|: TRUE f398_in(x21, x22) -> f398_out(0) :|: TRUE && x22 = 0 ---------------------------------------- (252) IntTRSCompressionProof (EQUIVALENT) Compressed rules. ---------------------------------------- (253) Obligation: Rules: f293_in(cons_0, x1:0) -> f304_out(0, x2:0) :|: TRUE && cons_0 = 0 f293_in(s(x3:0), s(x4:0)) -> f293_in(x3:0, x4:0) :|: TRUE f398_out(x17:0) -> f398_in(0, x18:0) :|: TRUE f304_out(x5:0, x6:0) -> f304_out(s(x5:0), s(x6:0)) :|: TRUE f293_in(s(x), x1) -> f304_out(s(x2), 0) :|: TRUE && x1 = 0 f398_in(x3, x4) -> f398_out(0) :|: TRUE && x4 = 0 f398_in(s(x12:0), s(x13:0)) -> f398_in(x12:0, x13:0) :|: TRUE f304_out(x15:0, x16:0) -> f398_in(s(x16:0), x15:0) :|: TRUE f398_out(x10:0) -> f293_in(x10:0, x11:0) :|: TRUE f398_out(x14:0) -> f398_out(s(x14:0)) :|: TRUE