YES proof of Transformed_CSR_04_Ex49_GM04_FR.trs # AProVE Commit ID: c69e44bd14796315568835c1ffa2502984884775 jera 20211004 unpublished Termination w.r.t. Q of the given QTRS could be proven: (0) QTRS (1) DependencyPairsProof [EQUIVALENT, 12 ms] (2) QDP (3) DependencyGraphProof [EQUIVALENT, 0 ms] (4) QDP (5) TransformationProof [EQUIVALENT, 1 ms] (6) QDP (7) DependencyGraphProof [EQUIVALENT, 0 ms] (8) QDP (9) QDPOrderProof [EQUIVALENT, 98 ms] (10) QDP (11) QDPOrderProof [EQUIVALENT, 117 ms] (12) QDP (13) DependencyGraphProof [EQUIVALENT, 0 ms] (14) AND (15) QDP (16) QDPOrderProof [EQUIVALENT, 17 ms] (17) QDP (18) PisEmptyProof [EQUIVALENT, 0 ms] (19) YES (20) QDP (21) QDPOrderProof [EQUIVALENT, 4 ms] (22) QDP (23) DependencyGraphProof [EQUIVALENT, 0 ms] (24) AND (25) QDP (26) QDPOrderProof [EQUIVALENT, 20 ms] (27) QDP (28) DependencyGraphProof [EQUIVALENT, 0 ms] (29) TRUE (30) QDP (31) QDPOrderProof [EQUIVALENT, 43 ms] (32) QDP (33) PisEmptyProof [EQUIVALENT, 0 ms] (34) YES ---------------------------------------- (0) Obligation: Q restricted rewrite system: The TRS R consists of the following rules: minus(n__0, Y) -> 0 minus(n__s(X), n__s(Y)) -> minus(activate(X), activate(Y)) geq(X, n__0) -> true geq(n__0, n__s(Y)) -> false geq(n__s(X), n__s(Y)) -> geq(activate(X), activate(Y)) div(0, n__s(Y)) -> 0 div(s(X), n__s(Y)) -> if(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) if(true, X, Y) -> activate(X) if(false, X, Y) -> activate(Y) 0 -> n__0 s(X) -> n__s(X) div(X1, X2) -> n__div(X1, X2) minus(X1, X2) -> n__minus(X1, X2) activate(n__0) -> 0 activate(n__s(X)) -> s(activate(X)) activate(n__div(X1, X2)) -> div(activate(X1), X2) activate(n__minus(X1, X2)) -> minus(X1, X2) activate(X) -> X Q is empty. ---------------------------------------- (1) DependencyPairsProof (EQUIVALENT) Using Dependency Pairs [AG00,LPAR04] we result in the following initial DP problem. ---------------------------------------- (2) Obligation: Q DP problem: The TRS P consists of the following rules: MINUS(n__0, Y) -> 0^1 MINUS(n__s(X), n__s(Y)) -> MINUS(activate(X), activate(Y)) MINUS(n__s(X), n__s(Y)) -> ACTIVATE(X) MINUS(n__s(X), n__s(Y)) -> ACTIVATE(Y) GEQ(n__s(X), n__s(Y)) -> GEQ(activate(X), activate(Y)) GEQ(n__s(X), n__s(Y)) -> ACTIVATE(X) GEQ(n__s(X), n__s(Y)) -> ACTIVATE(Y) DIV(s(X), n__s(Y)) -> IF(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) DIV(s(X), n__s(Y)) -> GEQ(X, activate(Y)) DIV(s(X), n__s(Y)) -> ACTIVATE(Y) IF(true, X, Y) -> ACTIVATE(X) IF(false, X, Y) -> ACTIVATE(Y) ACTIVATE(n__0) -> 0^1 ACTIVATE(n__s(X)) -> S(activate(X)) ACTIVATE(n__s(X)) -> ACTIVATE(X) ACTIVATE(n__div(X1, X2)) -> DIV(activate(X1), X2) ACTIVATE(n__div(X1, X2)) -> ACTIVATE(X1) ACTIVATE(n__minus(X1, X2)) -> MINUS(X1, X2) The TRS R consists of the following rules: minus(n__0, Y) -> 0 minus(n__s(X), n__s(Y)) -> minus(activate(X), activate(Y)) geq(X, n__0) -> true geq(n__0, n__s(Y)) -> false geq(n__s(X), n__s(Y)) -> geq(activate(X), activate(Y)) div(0, n__s(Y)) -> 0 div(s(X), n__s(Y)) -> if(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) if(true, X, Y) -> activate(X) if(false, X, Y) -> activate(Y) 0 -> n__0 s(X) -> n__s(X) div(X1, X2) -> n__div(X1, X2) minus(X1, X2) -> n__minus(X1, X2) activate(n__0) -> 0 activate(n__s(X)) -> s(activate(X)) activate(n__div(X1, X2)) -> div(activate(X1), X2) activate(n__minus(X1, X2)) -> minus(X1, X2) activate(X) -> X Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (3) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 3 less nodes. ---------------------------------------- (4) Obligation: Q DP problem: The TRS P consists of the following rules: MINUS(n__s(X), n__s(Y)) -> ACTIVATE(X) ACTIVATE(n__s(X)) -> ACTIVATE(X) ACTIVATE(n__div(X1, X2)) -> DIV(activate(X1), X2) DIV(s(X), n__s(Y)) -> IF(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) IF(true, X, Y) -> ACTIVATE(X) ACTIVATE(n__div(X1, X2)) -> ACTIVATE(X1) ACTIVATE(n__minus(X1, X2)) -> MINUS(X1, X2) MINUS(n__s(X), n__s(Y)) -> MINUS(activate(X), activate(Y)) MINUS(n__s(X), n__s(Y)) -> ACTIVATE(Y) IF(false, X, Y) -> ACTIVATE(Y) DIV(s(X), n__s(Y)) -> GEQ(X, activate(Y)) GEQ(n__s(X), n__s(Y)) -> GEQ(activate(X), activate(Y)) GEQ(n__s(X), n__s(Y)) -> ACTIVATE(X) GEQ(n__s(X), n__s(Y)) -> ACTIVATE(Y) DIV(s(X), n__s(Y)) -> ACTIVATE(Y) The TRS R consists of the following rules: minus(n__0, Y) -> 0 minus(n__s(X), n__s(Y)) -> minus(activate(X), activate(Y)) geq(X, n__0) -> true geq(n__0, n__s(Y)) -> false geq(n__s(X), n__s(Y)) -> geq(activate(X), activate(Y)) div(0, n__s(Y)) -> 0 div(s(X), n__s(Y)) -> if(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) if(true, X, Y) -> activate(X) if(false, X, Y) -> activate(Y) 0 -> n__0 s(X) -> n__s(X) div(X1, X2) -> n__div(X1, X2) minus(X1, X2) -> n__minus(X1, X2) activate(n__0) -> 0 activate(n__s(X)) -> s(activate(X)) activate(n__div(X1, X2)) -> div(activate(X1), X2) activate(n__minus(X1, X2)) -> minus(X1, X2) activate(X) -> X Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (5) TransformationProof (EQUIVALENT) By instantiating [LPAR04] the rule IF(false, X, Y) -> ACTIVATE(Y) we obtained the following new rules [LPAR04]: (IF(false, n__s(n__div(n__minus(y_4, y_6), n__s(y_8))), n__0) -> ACTIVATE(n__0),IF(false, n__s(n__div(n__minus(y_4, y_6), n__s(y_8))), n__0) -> ACTIVATE(n__0)) ---------------------------------------- (6) Obligation: Q DP problem: The TRS P consists of the following rules: MINUS(n__s(X), n__s(Y)) -> ACTIVATE(X) ACTIVATE(n__s(X)) -> ACTIVATE(X) ACTIVATE(n__div(X1, X2)) -> DIV(activate(X1), X2) DIV(s(X), n__s(Y)) -> IF(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) IF(true, X, Y) -> ACTIVATE(X) ACTIVATE(n__div(X1, X2)) -> ACTIVATE(X1) ACTIVATE(n__minus(X1, X2)) -> MINUS(X1, X2) MINUS(n__s(X), n__s(Y)) -> MINUS(activate(X), activate(Y)) MINUS(n__s(X), n__s(Y)) -> ACTIVATE(Y) DIV(s(X), n__s(Y)) -> GEQ(X, activate(Y)) GEQ(n__s(X), n__s(Y)) -> GEQ(activate(X), activate(Y)) GEQ(n__s(X), n__s(Y)) -> ACTIVATE(X) GEQ(n__s(X), n__s(Y)) -> ACTIVATE(Y) DIV(s(X), n__s(Y)) -> ACTIVATE(Y) IF(false, n__s(n__div(n__minus(y_4, y_6), n__s(y_8))), n__0) -> ACTIVATE(n__0) The TRS R consists of the following rules: minus(n__0, Y) -> 0 minus(n__s(X), n__s(Y)) -> minus(activate(X), activate(Y)) geq(X, n__0) -> true geq(n__0, n__s(Y)) -> false geq(n__s(X), n__s(Y)) -> geq(activate(X), activate(Y)) div(0, n__s(Y)) -> 0 div(s(X), n__s(Y)) -> if(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) if(true, X, Y) -> activate(X) if(false, X, Y) -> activate(Y) 0 -> n__0 s(X) -> n__s(X) div(X1, X2) -> n__div(X1, X2) minus(X1, X2) -> n__minus(X1, X2) activate(n__0) -> 0 activate(n__s(X)) -> s(activate(X)) activate(n__div(X1, X2)) -> div(activate(X1), X2) activate(n__minus(X1, X2)) -> minus(X1, X2) activate(X) -> X Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (7) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node. ---------------------------------------- (8) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVATE(n__s(X)) -> ACTIVATE(X) ACTIVATE(n__div(X1, X2)) -> DIV(activate(X1), X2) DIV(s(X), n__s(Y)) -> IF(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) IF(true, X, Y) -> ACTIVATE(X) ACTIVATE(n__div(X1, X2)) -> ACTIVATE(X1) ACTIVATE(n__minus(X1, X2)) -> MINUS(X1, X2) MINUS(n__s(X), n__s(Y)) -> MINUS(activate(X), activate(Y)) MINUS(n__s(X), n__s(Y)) -> ACTIVATE(X) MINUS(n__s(X), n__s(Y)) -> ACTIVATE(Y) DIV(s(X), n__s(Y)) -> GEQ(X, activate(Y)) GEQ(n__s(X), n__s(Y)) -> GEQ(activate(X), activate(Y)) GEQ(n__s(X), n__s(Y)) -> ACTIVATE(X) GEQ(n__s(X), n__s(Y)) -> ACTIVATE(Y) DIV(s(X), n__s(Y)) -> ACTIVATE(Y) The TRS R consists of the following rules: minus(n__0, Y) -> 0 minus(n__s(X), n__s(Y)) -> minus(activate(X), activate(Y)) geq(X, n__0) -> true geq(n__0, n__s(Y)) -> false geq(n__s(X), n__s(Y)) -> geq(activate(X), activate(Y)) div(0, n__s(Y)) -> 0 div(s(X), n__s(Y)) -> if(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) if(true, X, Y) -> activate(X) if(false, X, Y) -> activate(Y) 0 -> n__0 s(X) -> n__s(X) div(X1, X2) -> n__div(X1, X2) minus(X1, X2) -> n__minus(X1, X2) activate(n__0) -> 0 activate(n__s(X)) -> s(activate(X)) activate(n__div(X1, X2)) -> div(activate(X1), X2) activate(n__minus(X1, X2)) -> minus(X1, X2) activate(X) -> X Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (9) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. ACTIVATE(n__div(X1, X2)) -> ACTIVATE(X1) DIV(s(X), n__s(Y)) -> ACTIVATE(Y) The remaining pairs can at least be oriented weakly. Used ordering: Matrix interpretation [MATRO] with arctic natural numbers [ARCTIC]: <<< POL(ACTIVATE(x_1)) = [[0A]] + [[1A]] * x_1 >>> <<< POL(n__s(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(n__div(x_1, x_2)) = [[0A]] + [[4A]] * x_1 + [[4A]] * x_2 >>> <<< POL(DIV(x_1, x_2)) = [[1A]] + [[5A]] * x_1 + [[5A]] * x_2 >>> <<< POL(activate(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(s(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(IF(x_1, x_2, x_3)) = [[-I]] + [[0A]] * x_1 + [[1A]] * x_2 + [[1A]] * x_3 >>> <<< POL(geq(x_1, x_2)) = [[-I]] + [[0A]] * x_1 + [[2A]] * x_2 >>> <<< POL(n__minus(x_1, x_2)) = [[-I]] + [[0A]] * x_1 + [[0A]] * x_2 >>> <<< POL(n__0) = [[0A]] >>> <<< POL(true) = [[2A]] >>> <<< POL(MINUS(x_1, x_2)) = [[0A]] + [[1A]] * x_1 + [[1A]] * x_2 >>> <<< POL(GEQ(x_1, x_2)) = [[1A]] + [[1A]] * x_1 + [[1A]] * x_2 >>> <<< POL(0) = [[0A]] >>> <<< POL(div(x_1, x_2)) = [[0A]] + [[4A]] * x_1 + [[4A]] * x_2 >>> <<< POL(if(x_1, x_2, x_3)) = [[-I]] + [[0A]] * x_1 + [[0A]] * x_2 + [[0A]] * x_3 >>> <<< POL(false) = [[0A]] >>> <<< POL(minus(x_1, x_2)) = [[-I]] + [[0A]] * x_1 + [[0A]] * x_2 >>> The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: activate(n__0) -> 0 activate(n__s(X)) -> s(activate(X)) activate(n__div(X1, X2)) -> div(activate(X1), X2) div(s(X), n__s(Y)) -> if(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) if(true, X, Y) -> activate(X) if(false, X, Y) -> activate(Y) activate(n__minus(X1, X2)) -> minus(X1, X2) activate(X) -> X geq(X, n__0) -> true geq(n__0, n__s(Y)) -> false geq(n__s(X), n__s(Y)) -> geq(activate(X), activate(Y)) s(X) -> n__s(X) div(0, n__s(Y)) -> 0 div(X1, X2) -> n__div(X1, X2) minus(n__0, Y) -> 0 minus(X1, X2) -> n__minus(X1, X2) minus(n__s(X), n__s(Y)) -> minus(activate(X), activate(Y)) 0 -> n__0 ---------------------------------------- (10) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVATE(n__s(X)) -> ACTIVATE(X) ACTIVATE(n__div(X1, X2)) -> DIV(activate(X1), X2) DIV(s(X), n__s(Y)) -> IF(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) IF(true, X, Y) -> ACTIVATE(X) ACTIVATE(n__minus(X1, X2)) -> MINUS(X1, X2) MINUS(n__s(X), n__s(Y)) -> MINUS(activate(X), activate(Y)) MINUS(n__s(X), n__s(Y)) -> ACTIVATE(X) MINUS(n__s(X), n__s(Y)) -> ACTIVATE(Y) DIV(s(X), n__s(Y)) -> GEQ(X, activate(Y)) GEQ(n__s(X), n__s(Y)) -> GEQ(activate(X), activate(Y)) GEQ(n__s(X), n__s(Y)) -> ACTIVATE(X) GEQ(n__s(X), n__s(Y)) -> ACTIVATE(Y) The TRS R consists of the following rules: minus(n__0, Y) -> 0 minus(n__s(X), n__s(Y)) -> minus(activate(X), activate(Y)) geq(X, n__0) -> true geq(n__0, n__s(Y)) -> false geq(n__s(X), n__s(Y)) -> geq(activate(X), activate(Y)) div(0, n__s(Y)) -> 0 div(s(X), n__s(Y)) -> if(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) if(true, X, Y) -> activate(X) if(false, X, Y) -> activate(Y) 0 -> n__0 s(X) -> n__s(X) div(X1, X2) -> n__div(X1, X2) minus(X1, X2) -> n__minus(X1, X2) activate(n__0) -> 0 activate(n__s(X)) -> s(activate(X)) activate(n__div(X1, X2)) -> div(activate(X1), X2) activate(n__minus(X1, X2)) -> minus(X1, X2) activate(X) -> X Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (11) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. GEQ(n__s(X), n__s(Y)) -> ACTIVATE(X) GEQ(n__s(X), n__s(Y)) -> ACTIVATE(Y) The remaining pairs can at least be oriented weakly. Used ordering: Matrix interpretation [MATRO] with arctic natural numbers [ARCTIC]: <<< POL(ACTIVATE(x_1)) = [[0A]] + [[0A]] * x_1 >>> <<< POL(n__s(x_1)) = [[-I]] + [[0A]] * x_1 >>> <<< POL(n__div(x_1, x_2)) = [[5A]] + [[3A]] * x_1 + [[3A]] * x_2 >>> <<< POL(DIV(x_1, x_2)) = [[5A]] + [[3A]] * x_1 + [[3A]] * x_2 >>> <<< POL(activate(x_1)) = [[1A]] + [[0A]] * x_1 >>> <<< POL(s(x_1)) = [[1A]] + [[0A]] * x_1 >>> <<< POL(IF(x_1, x_2, x_3)) = [[1A]] + [[-I]] * x_1 + [[0A]] * x_2 + [[-I]] * x_3 >>> <<< POL(geq(x_1, x_2)) = [[1A]] + [[-I]] * x_1 + [[0A]] * x_2 >>> <<< POL(n__minus(x_1, x_2)) = [[1A]] + [[0A]] * x_1 + [[0A]] * x_2 >>> <<< POL(n__0) = [[3A]] >>> <<< POL(true) = [[3A]] >>> <<< POL(MINUS(x_1, x_2)) = [[1A]] + [[0A]] * x_1 + [[0A]] * x_2 >>> <<< POL(GEQ(x_1, x_2)) = [[5A]] + [[2A]] * x_1 + [[1A]] * x_2 >>> <<< POL(0) = [[3A]] >>> <<< POL(div(x_1, x_2)) = [[5A]] + [[3A]] * x_1 + [[3A]] * x_2 >>> <<< POL(if(x_1, x_2, x_3)) = [[-I]] + [[0A]] * x_1 + [[0A]] * x_2 + [[2A]] * x_3 >>> <<< POL(false) = [[1A]] >>> <<< POL(minus(x_1, x_2)) = [[1A]] + [[0A]] * x_1 + [[0A]] * x_2 >>> The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: activate(n__0) -> 0 activate(n__s(X)) -> s(activate(X)) activate(n__div(X1, X2)) -> div(activate(X1), X2) div(s(X), n__s(Y)) -> if(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) if(true, X, Y) -> activate(X) if(false, X, Y) -> activate(Y) activate(n__minus(X1, X2)) -> minus(X1, X2) activate(X) -> X geq(X, n__0) -> true geq(n__0, n__s(Y)) -> false geq(n__s(X), n__s(Y)) -> geq(activate(X), activate(Y)) s(X) -> n__s(X) div(0, n__s(Y)) -> 0 div(X1, X2) -> n__div(X1, X2) minus(n__0, Y) -> 0 minus(X1, X2) -> n__minus(X1, X2) minus(n__s(X), n__s(Y)) -> minus(activate(X), activate(Y)) 0 -> n__0 ---------------------------------------- (12) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVATE(n__s(X)) -> ACTIVATE(X) ACTIVATE(n__div(X1, X2)) -> DIV(activate(X1), X2) DIV(s(X), n__s(Y)) -> IF(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) IF(true, X, Y) -> ACTIVATE(X) ACTIVATE(n__minus(X1, X2)) -> MINUS(X1, X2) MINUS(n__s(X), n__s(Y)) -> MINUS(activate(X), activate(Y)) MINUS(n__s(X), n__s(Y)) -> ACTIVATE(X) MINUS(n__s(X), n__s(Y)) -> ACTIVATE(Y) DIV(s(X), n__s(Y)) -> GEQ(X, activate(Y)) GEQ(n__s(X), n__s(Y)) -> GEQ(activate(X), activate(Y)) The TRS R consists of the following rules: minus(n__0, Y) -> 0 minus(n__s(X), n__s(Y)) -> minus(activate(X), activate(Y)) geq(X, n__0) -> true geq(n__0, n__s(Y)) -> false geq(n__s(X), n__s(Y)) -> geq(activate(X), activate(Y)) div(0, n__s(Y)) -> 0 div(s(X), n__s(Y)) -> if(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) if(true, X, Y) -> activate(X) if(false, X, Y) -> activate(Y) 0 -> n__0 s(X) -> n__s(X) div(X1, X2) -> n__div(X1, X2) minus(X1, X2) -> n__minus(X1, X2) activate(n__0) -> 0 activate(n__s(X)) -> s(activate(X)) activate(n__div(X1, X2)) -> div(activate(X1), X2) activate(n__minus(X1, X2)) -> minus(X1, X2) activate(X) -> X Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (13) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 2 SCCs with 1 less node. ---------------------------------------- (14) Complex Obligation (AND) ---------------------------------------- (15) Obligation: Q DP problem: The TRS P consists of the following rules: GEQ(n__s(X), n__s(Y)) -> GEQ(activate(X), activate(Y)) The TRS R consists of the following rules: minus(n__0, Y) -> 0 minus(n__s(X), n__s(Y)) -> minus(activate(X), activate(Y)) geq(X, n__0) -> true geq(n__0, n__s(Y)) -> false geq(n__s(X), n__s(Y)) -> geq(activate(X), activate(Y)) div(0, n__s(Y)) -> 0 div(s(X), n__s(Y)) -> if(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) if(true, X, Y) -> activate(X) if(false, X, Y) -> activate(Y) 0 -> n__0 s(X) -> n__s(X) div(X1, X2) -> n__div(X1, X2) minus(X1, X2) -> n__minus(X1, X2) activate(n__0) -> 0 activate(n__s(X)) -> s(activate(X)) activate(n__div(X1, X2)) -> div(activate(X1), X2) activate(n__minus(X1, X2)) -> minus(X1, X2) activate(X) -> X Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (16) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. GEQ(n__s(X), n__s(Y)) -> GEQ(activate(X), activate(Y)) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( GEQ_2(x_1, x_2) ) = 2x_2 + 2 POL( activate_1(x_1) ) = x_1 POL( n__0 ) = 0 POL( 0 ) = 0 POL( n__s_1(x_1) ) = 2x_1 + 1 POL( s_1(x_1) ) = 2x_1 + 1 POL( n__div_2(x_1, x_2) ) = x_1 POL( div_2(x_1, x_2) ) = x_1 POL( if_3(x_1, ..., x_3) ) = max{0, x_1 + x_2 + 2x_3 - 2} POL( geq_2(x_1, x_2) ) = 2x_1 + 2 POL( n__minus_2(x_1, x_2) ) = max{0, -2} POL( true ) = 2 POL( false ) = 2 POL( minus_2(x_1, x_2) ) = 0 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: activate(n__0) -> 0 activate(n__s(X)) -> s(activate(X)) activate(n__div(X1, X2)) -> div(activate(X1), X2) div(s(X), n__s(Y)) -> if(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) if(true, X, Y) -> activate(X) if(false, X, Y) -> activate(Y) activate(n__minus(X1, X2)) -> minus(X1, X2) activate(X) -> X s(X) -> n__s(X) div(0, n__s(Y)) -> 0 div(X1, X2) -> n__div(X1, X2) geq(X, n__0) -> true geq(n__0, n__s(Y)) -> false minus(n__0, Y) -> 0 minus(X1, X2) -> n__minus(X1, X2) minus(n__s(X), n__s(Y)) -> minus(activate(X), activate(Y)) geq(n__s(X), n__s(Y)) -> geq(activate(X), activate(Y)) 0 -> n__0 ---------------------------------------- (17) Obligation: Q DP problem: P is empty. The TRS R consists of the following rules: minus(n__0, Y) -> 0 minus(n__s(X), n__s(Y)) -> minus(activate(X), activate(Y)) geq(X, n__0) -> true geq(n__0, n__s(Y)) -> false geq(n__s(X), n__s(Y)) -> geq(activate(X), activate(Y)) div(0, n__s(Y)) -> 0 div(s(X), n__s(Y)) -> if(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) if(true, X, Y) -> activate(X) if(false, X, Y) -> activate(Y) 0 -> n__0 s(X) -> n__s(X) div(X1, X2) -> n__div(X1, X2) minus(X1, X2) -> n__minus(X1, X2) activate(n__0) -> 0 activate(n__s(X)) -> s(activate(X)) activate(n__div(X1, X2)) -> div(activate(X1), X2) activate(n__minus(X1, X2)) -> minus(X1, X2) activate(X) -> X Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (18) PisEmptyProof (EQUIVALENT) The TRS P is empty. Hence, there is no (P,Q,R) chain. ---------------------------------------- (19) YES ---------------------------------------- (20) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVATE(n__div(X1, X2)) -> DIV(activate(X1), X2) DIV(s(X), n__s(Y)) -> IF(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) IF(true, X, Y) -> ACTIVATE(X) ACTIVATE(n__s(X)) -> ACTIVATE(X) ACTIVATE(n__minus(X1, X2)) -> MINUS(X1, X2) MINUS(n__s(X), n__s(Y)) -> MINUS(activate(X), activate(Y)) MINUS(n__s(X), n__s(Y)) -> ACTIVATE(X) MINUS(n__s(X), n__s(Y)) -> ACTIVATE(Y) The TRS R consists of the following rules: minus(n__0, Y) -> 0 minus(n__s(X), n__s(Y)) -> minus(activate(X), activate(Y)) geq(X, n__0) -> true geq(n__0, n__s(Y)) -> false geq(n__s(X), n__s(Y)) -> geq(activate(X), activate(Y)) div(0, n__s(Y)) -> 0 div(s(X), n__s(Y)) -> if(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) if(true, X, Y) -> activate(X) if(false, X, Y) -> activate(Y) 0 -> n__0 s(X) -> n__s(X) div(X1, X2) -> n__div(X1, X2) minus(X1, X2) -> n__minus(X1, X2) activate(n__0) -> 0 activate(n__s(X)) -> s(activate(X)) activate(n__div(X1, X2)) -> div(activate(X1), X2) activate(n__minus(X1, X2)) -> minus(X1, X2) activate(X) -> X Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (21) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. ACTIVATE(n__minus(X1, X2)) -> MINUS(X1, X2) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( DIV_2(x_1, x_2) ) = 2 POL( IF_3(x_1, ..., x_3) ) = 2x_1 + x_2 POL( MINUS_2(x_1, x_2) ) = 2x_1 + x_2 + 2 POL( n__div_2(x_1, x_2) ) = 0 POL( n__s_1(x_1) ) = 2x_1 POL( n__minus_2(x_1, x_2) ) = 2x_1 + x_2 + 2 POL( activate_1(x_1) ) = 2x_1 POL( n__0 ) = 0 POL( 0 ) = 0 POL( s_1(x_1) ) = 2x_1 POL( div_2(x_1, x_2) ) = 0 POL( if_3(x_1, ..., x_3) ) = max{0, 2x_1 + 2x_2 + 2x_3 - 2} POL( geq_2(x_1, x_2) ) = 1 POL( true ) = 1 POL( false ) = 1 POL( minus_2(x_1, x_2) ) = 2x_1 + x_2 + 2 POL( ACTIVATE_1(x_1) ) = x_1 + 2 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: activate(n__0) -> 0 activate(n__s(X)) -> s(activate(X)) activate(n__div(X1, X2)) -> div(activate(X1), X2) div(s(X), n__s(Y)) -> if(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) if(true, X, Y) -> activate(X) if(false, X, Y) -> activate(Y) activate(n__minus(X1, X2)) -> minus(X1, X2) activate(X) -> X geq(X, n__0) -> true geq(n__0, n__s(Y)) -> false geq(n__s(X), n__s(Y)) -> geq(activate(X), activate(Y)) s(X) -> n__s(X) div(0, n__s(Y)) -> 0 div(X1, X2) -> n__div(X1, X2) minus(n__0, Y) -> 0 minus(X1, X2) -> n__minus(X1, X2) minus(n__s(X), n__s(Y)) -> minus(activate(X), activate(Y)) 0 -> n__0 ---------------------------------------- (22) Obligation: Q DP problem: The TRS P consists of the following rules: ACTIVATE(n__div(X1, X2)) -> DIV(activate(X1), X2) DIV(s(X), n__s(Y)) -> IF(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) IF(true, X, Y) -> ACTIVATE(X) ACTIVATE(n__s(X)) -> ACTIVATE(X) MINUS(n__s(X), n__s(Y)) -> MINUS(activate(X), activate(Y)) MINUS(n__s(X), n__s(Y)) -> ACTIVATE(X) MINUS(n__s(X), n__s(Y)) -> ACTIVATE(Y) The TRS R consists of the following rules: minus(n__0, Y) -> 0 minus(n__s(X), n__s(Y)) -> minus(activate(X), activate(Y)) geq(X, n__0) -> true geq(n__0, n__s(Y)) -> false geq(n__s(X), n__s(Y)) -> geq(activate(X), activate(Y)) div(0, n__s(Y)) -> 0 div(s(X), n__s(Y)) -> if(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) if(true, X, Y) -> activate(X) if(false, X, Y) -> activate(Y) 0 -> n__0 s(X) -> n__s(X) div(X1, X2) -> n__div(X1, X2) minus(X1, X2) -> n__minus(X1, X2) activate(n__0) -> 0 activate(n__s(X)) -> s(activate(X)) activate(n__div(X1, X2)) -> div(activate(X1), X2) activate(n__minus(X1, X2)) -> minus(X1, X2) activate(X) -> X Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (23) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 2 SCCs with 2 less nodes. ---------------------------------------- (24) Complex Obligation (AND) ---------------------------------------- (25) Obligation: Q DP problem: The TRS P consists of the following rules: DIV(s(X), n__s(Y)) -> IF(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) IF(true, X, Y) -> ACTIVATE(X) ACTIVATE(n__s(X)) -> ACTIVATE(X) ACTIVATE(n__div(X1, X2)) -> DIV(activate(X1), X2) The TRS R consists of the following rules: minus(n__0, Y) -> 0 minus(n__s(X), n__s(Y)) -> minus(activate(X), activate(Y)) geq(X, n__0) -> true geq(n__0, n__s(Y)) -> false geq(n__s(X), n__s(Y)) -> geq(activate(X), activate(Y)) div(0, n__s(Y)) -> 0 div(s(X), n__s(Y)) -> if(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) if(true, X, Y) -> activate(X) if(false, X, Y) -> activate(Y) 0 -> n__0 s(X) -> n__s(X) div(X1, X2) -> n__div(X1, X2) minus(X1, X2) -> n__minus(X1, X2) activate(n__0) -> 0 activate(n__s(X)) -> s(activate(X)) activate(n__div(X1, X2)) -> div(activate(X1), X2) activate(n__minus(X1, X2)) -> minus(X1, X2) activate(X) -> X Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (26) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. DIV(s(X), n__s(Y)) -> IF(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) ACTIVATE(n__s(X)) -> ACTIVATE(X) ACTIVATE(n__div(X1, X2)) -> DIV(activate(X1), X2) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( DIV_2(x_1, x_2) ) = 2x_1 + 1 POL( IF_3(x_1, ..., x_3) ) = 2x_2 + x_3 + 2 POL( n__div_2(x_1, x_2) ) = 2x_1 POL( n__s_1(x_1) ) = x_1 + 1 POL( n__minus_2(x_1, x_2) ) = 0 POL( activate_1(x_1) ) = 2x_1 POL( n__0 ) = 0 POL( 0 ) = 0 POL( s_1(x_1) ) = x_1 + 2 POL( div_2(x_1, x_2) ) = 2x_1 POL( if_3(x_1, ..., x_3) ) = x_1 + 2x_2 + 2x_3 POL( geq_2(x_1, x_2) ) = 2 POL( true ) = 1 POL( false ) = 0 POL( minus_2(x_1, x_2) ) = 0 POL( ACTIVATE_1(x_1) ) = 2x_1 + 2 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: activate(n__0) -> 0 activate(n__s(X)) -> s(activate(X)) activate(n__div(X1, X2)) -> div(activate(X1), X2) div(s(X), n__s(Y)) -> if(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) if(true, X, Y) -> activate(X) if(false, X, Y) -> activate(Y) activate(n__minus(X1, X2)) -> minus(X1, X2) activate(X) -> X geq(X, n__0) -> true geq(n__0, n__s(Y)) -> false geq(n__s(X), n__s(Y)) -> geq(activate(X), activate(Y)) s(X) -> n__s(X) div(0, n__s(Y)) -> 0 div(X1, X2) -> n__div(X1, X2) minus(n__0, Y) -> 0 minus(X1, X2) -> n__minus(X1, X2) minus(n__s(X), n__s(Y)) -> minus(activate(X), activate(Y)) 0 -> n__0 ---------------------------------------- (27) Obligation: Q DP problem: The TRS P consists of the following rules: IF(true, X, Y) -> ACTIVATE(X) The TRS R consists of the following rules: minus(n__0, Y) -> 0 minus(n__s(X), n__s(Y)) -> minus(activate(X), activate(Y)) geq(X, n__0) -> true geq(n__0, n__s(Y)) -> false geq(n__s(X), n__s(Y)) -> geq(activate(X), activate(Y)) div(0, n__s(Y)) -> 0 div(s(X), n__s(Y)) -> if(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) if(true, X, Y) -> activate(X) if(false, X, Y) -> activate(Y) 0 -> n__0 s(X) -> n__s(X) div(X1, X2) -> n__div(X1, X2) minus(X1, X2) -> n__minus(X1, X2) activate(n__0) -> 0 activate(n__s(X)) -> s(activate(X)) activate(n__div(X1, X2)) -> div(activate(X1), X2) activate(n__minus(X1, X2)) -> minus(X1, X2) activate(X) -> X Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (28) DependencyGraphProof (EQUIVALENT) The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node. ---------------------------------------- (29) TRUE ---------------------------------------- (30) Obligation: Q DP problem: The TRS P consists of the following rules: MINUS(n__s(X), n__s(Y)) -> MINUS(activate(X), activate(Y)) The TRS R consists of the following rules: minus(n__0, Y) -> 0 minus(n__s(X), n__s(Y)) -> minus(activate(X), activate(Y)) geq(X, n__0) -> true geq(n__0, n__s(Y)) -> false geq(n__s(X), n__s(Y)) -> geq(activate(X), activate(Y)) div(0, n__s(Y)) -> 0 div(s(X), n__s(Y)) -> if(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) if(true, X, Y) -> activate(X) if(false, X, Y) -> activate(Y) 0 -> n__0 s(X) -> n__s(X) div(X1, X2) -> n__div(X1, X2) minus(X1, X2) -> n__minus(X1, X2) activate(n__0) -> 0 activate(n__s(X)) -> s(activate(X)) activate(n__div(X1, X2)) -> div(activate(X1), X2) activate(n__minus(X1, X2)) -> minus(X1, X2) activate(X) -> X Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (31) QDPOrderProof (EQUIVALENT) We use the reduction pair processor [LPAR04,JAR06]. The following pairs can be oriented strictly and are deleted. MINUS(n__s(X), n__s(Y)) -> MINUS(activate(X), activate(Y)) The remaining pairs can at least be oriented weakly. Used ordering: Polynomial Order [NEGPOLO,POLO] with Interpretation: POL( MINUS_2(x_1, x_2) ) = 2x_2 + 2 POL( activate_1(x_1) ) = x_1 POL( n__0 ) = 0 POL( 0 ) = 0 POL( n__s_1(x_1) ) = 2x_1 + 1 POL( s_1(x_1) ) = 2x_1 + 1 POL( n__div_2(x_1, x_2) ) = x_1 POL( div_2(x_1, x_2) ) = x_1 POL( if_3(x_1, ..., x_3) ) = max{0, x_1 + x_2 + 2x_3 - 2} POL( geq_2(x_1, x_2) ) = 2x_1 + 2 POL( n__minus_2(x_1, x_2) ) = max{0, -2} POL( true ) = 2 POL( false ) = 2 POL( minus_2(x_1, x_2) ) = 0 The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented: activate(n__0) -> 0 activate(n__s(X)) -> s(activate(X)) activate(n__div(X1, X2)) -> div(activate(X1), X2) div(s(X), n__s(Y)) -> if(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) if(true, X, Y) -> activate(X) if(false, X, Y) -> activate(Y) activate(n__minus(X1, X2)) -> minus(X1, X2) activate(X) -> X s(X) -> n__s(X) div(0, n__s(Y)) -> 0 div(X1, X2) -> n__div(X1, X2) geq(X, n__0) -> true geq(n__0, n__s(Y)) -> false minus(n__0, Y) -> 0 minus(X1, X2) -> n__minus(X1, X2) minus(n__s(X), n__s(Y)) -> minus(activate(X), activate(Y)) geq(n__s(X), n__s(Y)) -> geq(activate(X), activate(Y)) 0 -> n__0 ---------------------------------------- (32) Obligation: Q DP problem: P is empty. The TRS R consists of the following rules: minus(n__0, Y) -> 0 minus(n__s(X), n__s(Y)) -> minus(activate(X), activate(Y)) geq(X, n__0) -> true geq(n__0, n__s(Y)) -> false geq(n__s(X), n__s(Y)) -> geq(activate(X), activate(Y)) div(0, n__s(Y)) -> 0 div(s(X), n__s(Y)) -> if(geq(X, activate(Y)), n__s(n__div(n__minus(X, activate(Y)), n__s(activate(Y)))), n__0) if(true, X, Y) -> activate(X) if(false, X, Y) -> activate(Y) 0 -> n__0 s(X) -> n__s(X) div(X1, X2) -> n__div(X1, X2) minus(X1, X2) -> n__minus(X1, X2) activate(n__0) -> 0 activate(n__s(X)) -> s(activate(X)) activate(n__div(X1, X2)) -> div(activate(X1), X2) activate(n__minus(X1, X2)) -> minus(X1, X2) activate(X) -> X Q is empty. We have to consider all minimal (P,Q,R)-chains. ---------------------------------------- (33) PisEmptyProof (EQUIVALENT) The TRS P is empty. Hence, there is no (P,Q,R) chain. ---------------------------------------- (34) YES