/export/starexec/sandbox2/solver/bin/starexec_run_standard /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/output/output_files


--------------------------------------------------------------------------------


YES
proof of /export/starexec/sandbox2/benchmark/theBenchmark.xml
# AProVE Commit ID: 48fb2092695e11cc9f56e44b17a92a5f88ffb256 marcel 20180622 unpublished dirty


Termination w.r.t. Q of the given QTRS could be proven:

(0) QTRS
(1) DependencyPairsProof [EQUIVALENT, 0 ms]
(2) QDP
(3) DependencyGraphProof [EQUIVALENT, 0 ms]
(4) QDP
(5) TransformationProof [EQUIVALENT, 0 ms]
(6) QDP
(7) DependencyGraphProof [EQUIVALENT, 0 ms]
(8) QDP
(9) QDPOrderProof [EQUIVALENT, 200 ms]
(10) QDP
(11) QDPOrderProof [EQUIVALENT, 171 ms]
(12) QDP
(13) QDPOrderProof [EQUIVALENT, 46 ms]
(14) QDP
(15) DependencyGraphProof [EQUIVALENT, 0 ms]
(16) TRUE


----------------------------------------

(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.

   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)) =  	[[-I]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(n__s(x_1)) =  	[[-I]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(n__div(x_1, x_2)) =  	[[0A]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2
>>>

   <<<
 POL(DIV(x_1, x_2)) =  	[[0A]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[1A]] 	* 	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)) =  	[[0A]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[0A]] 	* 	x_2 	 +  	[[-I]] 	* 	x_3
>>>

   <<<
 POL(geq(x_1, x_2)) =  	[[-I]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2
>>>

   <<<
 POL(n__minus(x_1, x_2)) =  	[[0A]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[0A]] 	* 	x_2
>>>

   <<<
 POL(n__0) =  	[[0A]]
>>>

   <<<
 POL(true) =  	[[0A]]
>>>

   <<<
 POL(MINUS(x_1, x_2)) =  	[[0A]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[0A]] 	* 	x_2
>>>

   <<<
 POL(GEQ(x_1, x_2)) =  	[[0A]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[0A]] 	* 	x_2
>>>

   <<<
 POL(0) =  	[[0A]]
>>>

   <<<
 POL(div(x_1, x_2)) =  	[[0A]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2
>>>

   <<<
 POL(if(x_1, x_2, x_3)) =  	[[-I]] 	 +  	[[-I]] 	* 	x_1 	 +  	[[0A]] 	* 	x_2 	 +  	[[0A]] 	* 	x_3
>>>

   <<<
 POL(false) =  	[[0A]]
>>>

   <<<
 POL(minus(x_1, x_2)) =  	[[0A]] 	 +  	[[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__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)

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.

   MINUS(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)) =  	[[0A]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(n__div(x_1, x_2)) =  	[[-I]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2
>>>

   <<<
 POL(DIV(x_1, x_2)) =  	[[-I]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2
>>>

   <<<
 POL(activate(x_1)) =  	[[0A]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(s(x_1)) =  	[[0A]] 	 +  	[[0A]] 	* 	x_1
>>>

   <<<
 POL(IF(x_1, x_2, x_3)) =  	[[-I]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[0A]] 	* 	x_2 	 +  	[[-I]] 	* 	x_3
>>>

   <<<
 POL(geq(x_1, x_2)) =  	[[0A]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[0A]] 	* 	x_2
>>>

   <<<
 POL(n__minus(x_1, x_2)) =  	[[-I]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2
>>>

   <<<
 POL(n__0) =  	[[0A]]
>>>

   <<<
 POL(true) =  	[[0A]]
>>>

   <<<
 POL(MINUS(x_1, x_2)) =  	[[0A]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2
>>>

   <<<
 POL(GEQ(x_1, x_2)) =  	[[1A]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[0A]] 	* 	x_2
>>>

   <<<
 POL(0) =  	[[0A]]
>>>

   <<<
 POL(div(x_1, x_2)) =  	[[-I]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[1A]] 	* 	x_2
>>>

   <<<
 POL(if(x_1, x_2, x_3)) =  	[[1A]] 	 +  	[[-I]] 	* 	x_1 	 +  	[[0A]] 	* 	x_2 	 +  	[[1A]] 	* 	x_3
>>>

   <<<
 POL(false) =  	[[0A]]
>>>

   <<<
 POL(minus(x_1, x_2)) =  	[[0A]] 	 +  	[[0A]] 	* 	x_1 	 +  	[[1A]] 	* 	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__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)
   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.
----------------------------------------

(13) QDPOrderProof (EQUIVALENT)
We use the reduction pair processor [LPAR04,JAR06].


The following pairs can be oriented strictly and are deleted.

   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)
   MINUS(n__s(X), n__s(Y)) -> MINUS(activate(X), 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 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 + 2x_2 + 2
POL( GEQ_2(x_1, x_2) ) = x_1 + 2x_2 + 1
POL( IF_3(x_1, ..., x_3) ) = x_2 + 1
POL( MINUS_2(x_1, x_2) ) = x_1
POL( n__div_2(x_1, x_2) ) = 2x_1 + 2x_2 + 2
POL( n__s_1(x_1) ) = x_1 + 1
POL( n__minus_2(x_1, x_2) ) = x_1
POL( activate_1(x_1) ) = x_1
POL( n__0 ) = 0
POL( 0 ) = 0
POL( s_1(x_1) ) = x_1 + 1
POL( div_2(x_1, x_2) ) = 2x_1 + 2x_2 + 2
POL( if_3(x_1, ..., x_3) ) = x_2 + x_3
POL( geq_2(x_1, x_2) ) = max{0, -2}
POL( true ) = 0
POL( false ) = 0
POL( minus_2(x_1, x_2) ) = x_1
POL( ACTIVATE_1(x_1) ) = x_1 + 1

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


----------------------------------------

(14)
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)
   MINUS(n__s(X), n__s(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.
----------------------------------------

(15) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 3 less nodes.
----------------------------------------

(16)
TRUE