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

0 QTRS
↳1 DependencyPairsProof (⇔)
↳2 QDP
↳3 DependencyGraphProof (⇔)
↳4 AND
  ↳5 QDP
    ↳6 UsableRulesProof (⇔)
    ↳7 QDP
    ↳8 QDPSizeChangeProof (⇔)
    ↳9 TRUE
  ↳10 QDP
    ↳11 UsableRulesProof (⇔)
    ↳12 QDP
    ↳13 QDPSizeChangeProof (⇔)
    ↳14 TRUE
  ↳15 QDP
    ↳16 QDPOrderProof (⇔)
    ↳17 QDP
    ↳18 QDPOrderProof (⇔)
    ↳19 QDP
    ↳20 QDPOrderProof (⇔)
    ↳21 QDP
    ↳22 QDPSizeChangeProof (⇔)
    ↳23 TRUE
  ↳24 QDP
    ↳25 QDPOrderProof (⇔)
    ↳26 QDP
    ↳27 PisEmptyProof (⇔)
    ↳28 TRUE
  ↳29 QDP
    ↳30 QDPOrderProof (⇔)
    ↳31 QDP
    ↳32 PisEmptyProof (⇔)
    ↳33 TRUE
  ↳34 QDP
    ↳35 QDPSizeChangeProof (⇔)
    ↳36 TRUE
  ↳37 QDP
    ↳38 QDPOrderProof (⇔)
    ↳39 QDP
    ↳40 PisEmptyProof (⇔)
    ↳41 TRUE

(0) Obligation:

Q restricted rewrite system:
The TRS R consists of the following rules:

minus(x, 0) → x
minus(s(x), s(y)) → minus(x, y)
quot(0, s(y)) → 0
quot(s(x), s(y)) → s(quot(minus(x, y), s(y)))
plus(0, y) → y
plus(s(x), y) → s(plus(x, y))
minus(minus(x, y), z) → minus(x, plus(y, z))
app(nil, k) → k
app(l, nil) → l
app(cons(x, l), k) → cons(x, app(l, k))
sum(cons(x, nil)) → cons(x, nil)
sum(cons(x, cons(y, l))) → sum(cons(plus(x, y), l))
sum(app(l, cons(x, cons(y, k)))) → sum(app(l, sum(cons(x, cons(y, k)))))
plus(s(x), s(y)) → s(s(plus(if(gt(x, y), x, y), if(not(gt(x, y)), id(x), id(y)))))
plus(s(x), x) → plus(if(gt(x, x), id(x), id(x)), s(x))
plus(zero, y) → y
plus(id(x), s(y)) → s(plus(x, if(gt(s(y), y), y, s(y))))
id(x) → x
if(true, x, y) → x
if(false, x, y) → y
not(x) → if(x, false, true)
gt(s(x), zero) → true
gt(zero, y) → false
gt(s(x), s(y)) → gt(x, y)

Q is empty.

(1) DependencyPairsProof (EQUIVALENT transformation)

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(s(x), s(y)) → MINUS(x, y)
QUOT(s(x), s(y)) → QUOT(minus(x, y), s(y))
QUOT(s(x), s(y)) → MINUS(x, y)
PLUS(s(x), y) → PLUS(x, y)
MINUS(minus(x, y), z) → MINUS(x, plus(y, z))
MINUS(minus(x, y), z) → PLUS(y, z)
APP(cons(x, l), k) → APP(l, k)
SUM(cons(x, cons(y, l))) → SUM(cons(plus(x, y), l))
SUM(cons(x, cons(y, l))) → PLUS(x, y)
SUM(app(l, cons(x, cons(y, k)))) → SUM(app(l, sum(cons(x, cons(y, k)))))
SUM(app(l, cons(x, cons(y, k)))) → APP(l, sum(cons(x, cons(y, k))))
SUM(app(l, cons(x, cons(y, k)))) → SUM(cons(x, cons(y, k)))
PLUS(s(x), s(y)) → PLUS(if(gt(x, y), x, y), if(not(gt(x, y)), id(x), id(y)))
PLUS(s(x), s(y)) → IF(gt(x, y), x, y)
PLUS(s(x), s(y)) → GT(x, y)
PLUS(s(x), s(y)) → IF(not(gt(x, y)), id(x), id(y))
PLUS(s(x), s(y)) → NOT(gt(x, y))
PLUS(s(x), s(y)) → ID(x)
PLUS(s(x), s(y)) → ID(y)
PLUS(s(x), x) → PLUS(if(gt(x, x), id(x), id(x)), s(x))
PLUS(s(x), x) → IF(gt(x, x), id(x), id(x))
PLUS(s(x), x) → GT(x, x)
PLUS(s(x), x) → ID(x)
PLUS(id(x), s(y)) → PLUS(x, if(gt(s(y), y), y, s(y)))
PLUS(id(x), s(y)) → IF(gt(s(y), y), y, s(y))
PLUS(id(x), s(y)) → GT(s(y), y)
NOT(x) → IF(x, false, true)
GT(s(x), s(y)) → GT(x, y)

The TRS R consists of the following rules:

minus(x, 0) → x
minus(s(x), s(y)) → minus(x, y)
quot(0, s(y)) → 0
quot(s(x), s(y)) → s(quot(minus(x, y), s(y)))
plus(0, y) → y
plus(s(x), y) → s(plus(x, y))
minus(minus(x, y), z) → minus(x, plus(y, z))
app(nil, k) → k
app(l, nil) → l
app(cons(x, l), k) → cons(x, app(l, k))
sum(cons(x, nil)) → cons(x, nil)
sum(cons(x, cons(y, l))) → sum(cons(plus(x, y), l))
sum(app(l, cons(x, cons(y, k)))) → sum(app(l, sum(cons(x, cons(y, k)))))
plus(s(x), s(y)) → s(s(plus(if(gt(x, y), x, y), if(not(gt(x, y)), id(x), id(y)))))
plus(s(x), x) → plus(if(gt(x, x), id(x), id(x)), s(x))
plus(zero, y) → y
plus(id(x), s(y)) → s(plus(x, if(gt(s(y), y), y, s(y))))
id(x) → x
if(true, x, y) → x
if(false, x, y) → y
not(x) → if(x, false, true)
gt(s(x), zero) → true
gt(zero, y) → false
gt(s(x), s(y)) → gt(x, y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(3) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 7 SCCs with 17 less nodes.

(4) Complex Obligation (AND)

(5) Obligation:

Q DP problem:
The TRS P consists of the following rules:

GT(s(x), s(y)) → GT(x, y)

The TRS R consists of the following rules:

minus(x, 0) → x
minus(s(x), s(y)) → minus(x, y)
quot(0, s(y)) → 0
quot(s(x), s(y)) → s(quot(minus(x, y), s(y)))
plus(0, y) → y
plus(s(x), y) → s(plus(x, y))
minus(minus(x, y), z) → minus(x, plus(y, z))
app(nil, k) → k
app(l, nil) → l
app(cons(x, l), k) → cons(x, app(l, k))
sum(cons(x, nil)) → cons(x, nil)
sum(cons(x, cons(y, l))) → sum(cons(plus(x, y), l))
sum(app(l, cons(x, cons(y, k)))) → sum(app(l, sum(cons(x, cons(y, k)))))
plus(s(x), s(y)) → s(s(plus(if(gt(x, y), x, y), if(not(gt(x, y)), id(x), id(y)))))
plus(s(x), x) → plus(if(gt(x, x), id(x), id(x)), s(x))
plus(zero, y) → y
plus(id(x), s(y)) → s(plus(x, if(gt(s(y), y), y, s(y))))
id(x) → x
if(true, x, y) → x
if(false, x, y) → y
not(x) → if(x, false, true)
gt(s(x), zero) → true
gt(zero, y) → false
gt(s(x), s(y)) → gt(x, y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(6) UsableRulesProof (EQUIVALENT transformation)

We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R.

(7) Obligation:

Q DP problem:
The TRS P consists of the following rules:

GT(s(x), s(y)) → GT(x, y)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(8) QDPSizeChangeProof (EQUIVALENT transformation)

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:

  • GT(s(x), s(y)) → GT(x, y)
    The graph contains the following edges 1 > 1, 2 > 2

(9) TRUE

(10) Obligation:

Q DP problem:
The TRS P consists of the following rules:

APP(cons(x, l), k) → APP(l, k)

The TRS R consists of the following rules:

minus(x, 0) → x
minus(s(x), s(y)) → minus(x, y)
quot(0, s(y)) → 0
quot(s(x), s(y)) → s(quot(minus(x, y), s(y)))
plus(0, y) → y
plus(s(x), y) → s(plus(x, y))
minus(minus(x, y), z) → minus(x, plus(y, z))
app(nil, k) → k
app(l, nil) → l
app(cons(x, l), k) → cons(x, app(l, k))
sum(cons(x, nil)) → cons(x, nil)
sum(cons(x, cons(y, l))) → sum(cons(plus(x, y), l))
sum(app(l, cons(x, cons(y, k)))) → sum(app(l, sum(cons(x, cons(y, k)))))
plus(s(x), s(y)) → s(s(plus(if(gt(x, y), x, y), if(not(gt(x, y)), id(x), id(y)))))
plus(s(x), x) → plus(if(gt(x, x), id(x), id(x)), s(x))
plus(zero, y) → y
plus(id(x), s(y)) → s(plus(x, if(gt(s(y), y), y, s(y))))
id(x) → x
if(true, x, y) → x
if(false, x, y) → y
not(x) → if(x, false, true)
gt(s(x), zero) → true
gt(zero, y) → false
gt(s(x), s(y)) → gt(x, y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(11) UsableRulesProof (EQUIVALENT transformation)

We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R.

(12) Obligation:

Q DP problem:
The TRS P consists of the following rules:

APP(cons(x, l), k) → APP(l, k)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(13) QDPSizeChangeProof (EQUIVALENT transformation)

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:

  • APP(cons(x, l), k) → APP(l, k)
    The graph contains the following edges 1 > 1, 2 >= 2

(14) TRUE

(15) Obligation:

Q DP problem:
The TRS P consists of the following rules:

PLUS(s(x), s(y)) → PLUS(if(gt(x, y), x, y), if(not(gt(x, y)), id(x), id(y)))
PLUS(s(x), y) → PLUS(x, y)
PLUS(s(x), x) → PLUS(if(gt(x, x), id(x), id(x)), s(x))
PLUS(id(x), s(y)) → PLUS(x, if(gt(s(y), y), y, s(y)))

The TRS R consists of the following rules:

minus(x, 0) → x
minus(s(x), s(y)) → minus(x, y)
quot(0, s(y)) → 0
quot(s(x), s(y)) → s(quot(minus(x, y), s(y)))
plus(0, y) → y
plus(s(x), y) → s(plus(x, y))
minus(minus(x, y), z) → minus(x, plus(y, z))
app(nil, k) → k
app(l, nil) → l
app(cons(x, l), k) → cons(x, app(l, k))
sum(cons(x, nil)) → cons(x, nil)
sum(cons(x, cons(y, l))) → sum(cons(plus(x, y), l))
sum(app(l, cons(x, cons(y, k)))) → sum(app(l, sum(cons(x, cons(y, k)))))
plus(s(x), s(y)) → s(s(plus(if(gt(x, y), x, y), if(not(gt(x, y)), id(x), id(y)))))
plus(s(x), x) → plus(if(gt(x, x), id(x), id(x)), s(x))
plus(zero, y) → y
plus(id(x), s(y)) → s(plus(x, if(gt(s(y), y), y, s(y))))
id(x) → x
if(true, x, y) → x
if(false, x, y) → y
not(x) → if(x, false, true)
gt(s(x), zero) → true
gt(zero, y) → false
gt(s(x), s(y)) → gt(x, y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(16) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


PLUS(s(x), s(y)) → PLUS(if(gt(x, y), x, y), if(not(gt(x, y)), id(x), id(y)))
The remaining pairs can at least be oriented weakly.
Used ordering: Matrix interpretation [MATRO] with arctic natural numbers [ARCTIC]:

POL(PLUS(x1, x2)) = -I + 0A·x1 + 0A·x2

POL(s(x1)) = -I + 1A·x1

POL(if(x1, x2, x3)) = -I + -I·x1 + 0A·x2 + 0A·x3

POL(gt(x1, x2)) = 0A + 0A·x1 + -I·x2

POL(not(x1)) = -I + 1A·x1

POL(id(x1)) = -I + 0A·x1

POL(true) = 0A

POL(false) = 5A

POL(zero) = 0A

The following usable rules [FROCOS05] were oriented:

id(x) → x
if(true, x, y) → x
if(false, x, y) → y

(17) Obligation:

Q DP problem:
The TRS P consists of the following rules:

PLUS(s(x), y) → PLUS(x, y)
PLUS(s(x), x) → PLUS(if(gt(x, x), id(x), id(x)), s(x))
PLUS(id(x), s(y)) → PLUS(x, if(gt(s(y), y), y, s(y)))

The TRS R consists of the following rules:

minus(x, 0) → x
minus(s(x), s(y)) → minus(x, y)
quot(0, s(y)) → 0
quot(s(x), s(y)) → s(quot(minus(x, y), s(y)))
plus(0, y) → y
plus(s(x), y) → s(plus(x, y))
minus(minus(x, y), z) → minus(x, plus(y, z))
app(nil, k) → k
app(l, nil) → l
app(cons(x, l), k) → cons(x, app(l, k))
sum(cons(x, nil)) → cons(x, nil)
sum(cons(x, cons(y, l))) → sum(cons(plus(x, y), l))
sum(app(l, cons(x, cons(y, k)))) → sum(app(l, sum(cons(x, cons(y, k)))))
plus(s(x), s(y)) → s(s(plus(if(gt(x, y), x, y), if(not(gt(x, y)), id(x), id(y)))))
plus(s(x), x) → plus(if(gt(x, x), id(x), id(x)), s(x))
plus(zero, y) → y
plus(id(x), s(y)) → s(plus(x, if(gt(s(y), y), y, s(y))))
id(x) → x
if(true, x, y) → x
if(false, x, y) → y
not(x) → if(x, false, true)
gt(s(x), zero) → true
gt(zero, y) → false
gt(s(x), s(y)) → gt(x, y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(18) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


PLUS(s(x), y) → PLUS(x, y)
The remaining pairs can at least be oriented weakly.
Used ordering: Matrix interpretation [MATRO]:

POL(PLUS(x1, x2)) =
/0\
\0/
 +
/11\
\00/
·x1 +
/00\
\00/
·x2

POL(s(x1)) =
/1\
\1/
 +
/11\
\11/
·x1

POL(if(x1, x2, x3)) =
/0\
\1/
 +
/00\
\10/
·x1 +
/10\
\01/
·x2 +
/10\
\01/
·x3

POL(gt(x1, x2)) =
/1\
\0/
 +
/00\
\00/
·x1 +
/00\
\00/
·x2

POL(id(x1)) =
/0\
\0/
 +
/10\
\01/
·x1

POL(true) =
/1\
\0/

POL(false) =
/1\
\0/

POL(zero) =
/0\
\0/

The following usable rules [FROCOS05] were oriented:

id(x) → x
if(true, x, y) → x
if(false, x, y) → y
gt(s(x), zero) → true
gt(s(x), s(y)) → gt(x, y)
gt(zero, y) → false

(19) Obligation:

Q DP problem:
The TRS P consists of the following rules:

PLUS(s(x), x) → PLUS(if(gt(x, x), id(x), id(x)), s(x))
PLUS(id(x), s(y)) → PLUS(x, if(gt(s(y), y), y, s(y)))

The TRS R consists of the following rules:

minus(x, 0) → x
minus(s(x), s(y)) → minus(x, y)
quot(0, s(y)) → 0
quot(s(x), s(y)) → s(quot(minus(x, y), s(y)))
plus(0, y) → y
plus(s(x), y) → s(plus(x, y))
minus(minus(x, y), z) → minus(x, plus(y, z))
app(nil, k) → k
app(l, nil) → l
app(cons(x, l), k) → cons(x, app(l, k))
sum(cons(x, nil)) → cons(x, nil)
sum(cons(x, cons(y, l))) → sum(cons(plus(x, y), l))
sum(app(l, cons(x, cons(y, k)))) → sum(app(l, sum(cons(x, cons(y, k)))))
plus(s(x), s(y)) → s(s(plus(if(gt(x, y), x, y), if(not(gt(x, y)), id(x), id(y)))))
plus(s(x), x) → plus(if(gt(x, x), id(x), id(x)), s(x))
plus(zero, y) → y
plus(id(x), s(y)) → s(plus(x, if(gt(s(y), y), y, s(y))))
id(x) → x
if(true, x, y) → x
if(false, x, y) → y
not(x) → if(x, false, true)
gt(s(x), zero) → true
gt(zero, y) → false
gt(s(x), s(y)) → gt(x, y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(20) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


PLUS(s(x), x) → PLUS(if(gt(x, x), id(x), id(x)), s(x))
The remaining pairs can at least be oriented weakly.
Used ordering: Matrix interpretation [MATRO]:

POL(PLUS(x1, x2)) =
/0\
\0/
 +
/11\
\00/
·x1 +
/00\
\00/
·x2

POL(s(x1)) =
/1\
\1/
 +
/11\
\11/
·x1

POL(if(x1, x2, x3)) =
/0\
\0/
 +
/00\
\00/
·x1 +
/10\
\01/
·x2 +
/10\
\01/
·x3

POL(gt(x1, x2)) =
/0\
\0/
 +
/00\
\00/
·x1 +
/00\
\00/
·x2

POL(id(x1)) =
/0\
\0/
 +
/10\
\01/
·x1

POL(true) =
/1\
\1/

POL(false) =
/1\
\1/

POL(zero) =
/0\
\0/

The following usable rules [FROCOS05] were oriented:

id(x) → x
if(true, x, y) → x
if(false, x, y) → y

(21) Obligation:

Q DP problem:
The TRS P consists of the following rules:

PLUS(id(x), s(y)) → PLUS(x, if(gt(s(y), y), y, s(y)))

The TRS R consists of the following rules:

minus(x, 0) → x
minus(s(x), s(y)) → minus(x, y)
quot(0, s(y)) → 0
quot(s(x), s(y)) → s(quot(minus(x, y), s(y)))
plus(0, y) → y
plus(s(x), y) → s(plus(x, y))
minus(minus(x, y), z) → minus(x, plus(y, z))
app(nil, k) → k
app(l, nil) → l
app(cons(x, l), k) → cons(x, app(l, k))
sum(cons(x, nil)) → cons(x, nil)
sum(cons(x, cons(y, l))) → sum(cons(plus(x, y), l))
sum(app(l, cons(x, cons(y, k)))) → sum(app(l, sum(cons(x, cons(y, k)))))
plus(s(x), s(y)) → s(s(plus(if(gt(x, y), x, y), if(not(gt(x, y)), id(x), id(y)))))
plus(s(x), x) → plus(if(gt(x, x), id(x), id(x)), s(x))
plus(zero, y) → y
plus(id(x), s(y)) → s(plus(x, if(gt(s(y), y), y, s(y))))
id(x) → x
if(true, x, y) → x
if(false, x, y) → y
not(x) → if(x, false, true)
gt(s(x), zero) → true
gt(zero, y) → false
gt(s(x), s(y)) → gt(x, y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(22) QDPSizeChangeProof (EQUIVALENT transformation)

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:

  • PLUS(id(x), s(y)) → PLUS(x, if(gt(s(y), y), y, s(y)))
    The graph contains the following edges 1 > 1

(23) TRUE

(24) Obligation:

Q DP problem:
The TRS P consists of the following rules:

SUM(cons(x, cons(y, l))) → SUM(cons(plus(x, y), l))

The TRS R consists of the following rules:

minus(x, 0) → x
minus(s(x), s(y)) → minus(x, y)
quot(0, s(y)) → 0
quot(s(x), s(y)) → s(quot(minus(x, y), s(y)))
plus(0, y) → y
plus(s(x), y) → s(plus(x, y))
minus(minus(x, y), z) → minus(x, plus(y, z))
app(nil, k) → k
app(l, nil) → l
app(cons(x, l), k) → cons(x, app(l, k))
sum(cons(x, nil)) → cons(x, nil)
sum(cons(x, cons(y, l))) → sum(cons(plus(x, y), l))
sum(app(l, cons(x, cons(y, k)))) → sum(app(l, sum(cons(x, cons(y, k)))))
plus(s(x), s(y)) → s(s(plus(if(gt(x, y), x, y), if(not(gt(x, y)), id(x), id(y)))))
plus(s(x), x) → plus(if(gt(x, x), id(x), id(x)), s(x))
plus(zero, y) → y
plus(id(x), s(y)) → s(plus(x, if(gt(s(y), y), y, s(y))))
id(x) → x
if(true, x, y) → x
if(false, x, y) → y
not(x) → if(x, false, true)
gt(s(x), zero) → true
gt(zero, y) → false
gt(s(x), s(y)) → gt(x, y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(25) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


SUM(cons(x, cons(y, l))) → SUM(cons(plus(x, y), l))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0   
POL(SUM(x1)) = x1   
POL(cons(x1, x2)) = 1 + x2   
POL(false) = 0   
POL(gt(x1, x2)) = 0   
POL(id(x1)) = x1   
POL(if(x1, x2, x3)) = 0   
POL(not(x1)) = 1 + x1   
POL(plus(x1, x2)) = 0   
POL(s(x1)) = 0   
POL(true) = 0   
POL(zero) = 0   

The following usable rules [FROCOS05] were oriented: none

(26) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

minus(x, 0) → x
minus(s(x), s(y)) → minus(x, y)
quot(0, s(y)) → 0
quot(s(x), s(y)) → s(quot(minus(x, y), s(y)))
plus(0, y) → y
plus(s(x), y) → s(plus(x, y))
minus(minus(x, y), z) → minus(x, plus(y, z))
app(nil, k) → k
app(l, nil) → l
app(cons(x, l), k) → cons(x, app(l, k))
sum(cons(x, nil)) → cons(x, nil)
sum(cons(x, cons(y, l))) → sum(cons(plus(x, y), l))
sum(app(l, cons(x, cons(y, k)))) → sum(app(l, sum(cons(x, cons(y, k)))))
plus(s(x), s(y)) → s(s(plus(if(gt(x, y), x, y), if(not(gt(x, y)), id(x), id(y)))))
plus(s(x), x) → plus(if(gt(x, x), id(x), id(x)), s(x))
plus(zero, y) → y
plus(id(x), s(y)) → s(plus(x, if(gt(s(y), y), y, s(y))))
id(x) → x
if(true, x, y) → x
if(false, x, y) → y
not(x) → if(x, false, true)
gt(s(x), zero) → true
gt(zero, y) → false
gt(s(x), s(y)) → gt(x, y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(27) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(28) TRUE

(29) Obligation:

Q DP problem:
The TRS P consists of the following rules:

SUM(app(l, cons(x, cons(y, k)))) → SUM(app(l, sum(cons(x, cons(y, k)))))

The TRS R consists of the following rules:

minus(x, 0) → x
minus(s(x), s(y)) → minus(x, y)
quot(0, s(y)) → 0
quot(s(x), s(y)) → s(quot(minus(x, y), s(y)))
plus(0, y) → y
plus(s(x), y) → s(plus(x, y))
minus(minus(x, y), z) → minus(x, plus(y, z))
app(nil, k) → k
app(l, nil) → l
app(cons(x, l), k) → cons(x, app(l, k))
sum(cons(x, nil)) → cons(x, nil)
sum(cons(x, cons(y, l))) → sum(cons(plus(x, y), l))
sum(app(l, cons(x, cons(y, k)))) → sum(app(l, sum(cons(x, cons(y, k)))))
plus(s(x), s(y)) → s(s(plus(if(gt(x, y), x, y), if(not(gt(x, y)), id(x), id(y)))))
plus(s(x), x) → plus(if(gt(x, x), id(x), id(x)), s(x))
plus(zero, y) → y
plus(id(x), s(y)) → s(plus(x, if(gt(s(y), y), y, s(y))))
id(x) → x
if(true, x, y) → x
if(false, x, y) → y
not(x) → if(x, false, true)
gt(s(x), zero) → true
gt(zero, y) → false
gt(s(x), s(y)) → gt(x, y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(30) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


SUM(app(l, cons(x, cons(y, k)))) → SUM(app(l, sum(cons(x, cons(y, k)))))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0   
POL(SUM(x1)) = x1   
POL(app(x1, x2)) = x1 + x2   
POL(cons(x1, x2)) = 1 + x2   
POL(false) = 0   
POL(gt(x1, x2)) = 0   
POL(id(x1)) = x1   
POL(if(x1, x2, x3)) = 0   
POL(nil) = 0   
POL(not(x1)) = 1 + x1   
POL(plus(x1, x2)) = 1 + x1 + x2   
POL(s(x1)) = 1   
POL(sum(x1)) = 1   
POL(true) = 0   
POL(zero) = 0   

The following usable rules [FROCOS05] were oriented:

app(l, nil) → l
app(cons(x, l), k) → cons(x, app(l, k))
sum(cons(x, nil)) → cons(x, nil)
sum(cons(x, cons(y, l))) → sum(cons(plus(x, y), l))
app(nil, k) → k

(31) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

minus(x, 0) → x
minus(s(x), s(y)) → minus(x, y)
quot(0, s(y)) → 0
quot(s(x), s(y)) → s(quot(minus(x, y), s(y)))
plus(0, y) → y
plus(s(x), y) → s(plus(x, y))
minus(minus(x, y), z) → minus(x, plus(y, z))
app(nil, k) → k
app(l, nil) → l
app(cons(x, l), k) → cons(x, app(l, k))
sum(cons(x, nil)) → cons(x, nil)
sum(cons(x, cons(y, l))) → sum(cons(plus(x, y), l))
sum(app(l, cons(x, cons(y, k)))) → sum(app(l, sum(cons(x, cons(y, k)))))
plus(s(x), s(y)) → s(s(plus(if(gt(x, y), x, y), if(not(gt(x, y)), id(x), id(y)))))
plus(s(x), x) → plus(if(gt(x, x), id(x), id(x)), s(x))
plus(zero, y) → y
plus(id(x), s(y)) → s(plus(x, if(gt(s(y), y), y, s(y))))
id(x) → x
if(true, x, y) → x
if(false, x, y) → y
not(x) → if(x, false, true)
gt(s(x), zero) → true
gt(zero, y) → false
gt(s(x), s(y)) → gt(x, y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(32) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(33) TRUE

(34) Obligation:

Q DP problem:
The TRS P consists of the following rules:

MINUS(minus(x, y), z) → MINUS(x, plus(y, z))
MINUS(s(x), s(y)) → MINUS(x, y)

The TRS R consists of the following rules:

minus(x, 0) → x
minus(s(x), s(y)) → minus(x, y)
quot(0, s(y)) → 0
quot(s(x), s(y)) → s(quot(minus(x, y), s(y)))
plus(0, y) → y
plus(s(x), y) → s(plus(x, y))
minus(minus(x, y), z) → minus(x, plus(y, z))
app(nil, k) → k
app(l, nil) → l
app(cons(x, l), k) → cons(x, app(l, k))
sum(cons(x, nil)) → cons(x, nil)
sum(cons(x, cons(y, l))) → sum(cons(plus(x, y), l))
sum(app(l, cons(x, cons(y, k)))) → sum(app(l, sum(cons(x, cons(y, k)))))
plus(s(x), s(y)) → s(s(plus(if(gt(x, y), x, y), if(not(gt(x, y)), id(x), id(y)))))
plus(s(x), x) → plus(if(gt(x, x), id(x), id(x)), s(x))
plus(zero, y) → y
plus(id(x), s(y)) → s(plus(x, if(gt(s(y), y), y, s(y))))
id(x) → x
if(true, x, y) → x
if(false, x, y) → y
not(x) → if(x, false, true)
gt(s(x), zero) → true
gt(zero, y) → false
gt(s(x), s(y)) → gt(x, y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(35) QDPSizeChangeProof (EQUIVALENT transformation)

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(minus(x, y), z) → MINUS(x, plus(y, z))
    The graph contains the following edges 1 > 1

  • MINUS(s(x), s(y)) → MINUS(x, y)
    The graph contains the following edges 1 > 1, 2 > 2

(36) TRUE

(37) Obligation:

Q DP problem:
The TRS P consists of the following rules:

QUOT(s(x), s(y)) → QUOT(minus(x, y), s(y))

The TRS R consists of the following rules:

minus(x, 0) → x
minus(s(x), s(y)) → minus(x, y)
quot(0, s(y)) → 0
quot(s(x), s(y)) → s(quot(minus(x, y), s(y)))
plus(0, y) → y
plus(s(x), y) → s(plus(x, y))
minus(minus(x, y), z) → minus(x, plus(y, z))
app(nil, k) → k
app(l, nil) → l
app(cons(x, l), k) → cons(x, app(l, k))
sum(cons(x, nil)) → cons(x, nil)
sum(cons(x, cons(y, l))) → sum(cons(plus(x, y), l))
sum(app(l, cons(x, cons(y, k)))) → sum(app(l, sum(cons(x, cons(y, k)))))
plus(s(x), s(y)) → s(s(plus(if(gt(x, y), x, y), if(not(gt(x, y)), id(x), id(y)))))
plus(s(x), x) → plus(if(gt(x, x), id(x), id(x)), s(x))
plus(zero, y) → y
plus(id(x), s(y)) → s(plus(x, if(gt(s(y), y), y, s(y))))
id(x) → x
if(true, x, y) → x
if(false, x, y) → y
not(x) → if(x, false, true)
gt(s(x), zero) → true
gt(zero, y) → false
gt(s(x), s(y)) → gt(x, y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(38) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


QUOT(s(x), s(y)) → QUOT(minus(x, y), s(y))
The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0   
POL(QUOT(x1, x2)) = x1   
POL(false) = 0   
POL(gt(x1, x2)) = 1 + x1   
POL(id(x1)) = 0   
POL(if(x1, x2, x3)) = x2 + x3   
POL(minus(x1, x2)) = x1   
POL(not(x1)) = 1 + x1   
POL(plus(x1, x2)) = 0   
POL(s(x1)) = 1 + x1   
POL(true) = 0   
POL(zero) = 0   

The following usable rules [FROCOS05] were oriented:

minus(x, 0) → x
minus(s(x), s(y)) → minus(x, y)
minus(minus(x, y), z) → minus(x, plus(y, z))

(39) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

minus(x, 0) → x
minus(s(x), s(y)) → minus(x, y)
quot(0, s(y)) → 0
quot(s(x), s(y)) → s(quot(minus(x, y), s(y)))
plus(0, y) → y
plus(s(x), y) → s(plus(x, y))
minus(minus(x, y), z) → minus(x, plus(y, z))
app(nil, k) → k
app(l, nil) → l
app(cons(x, l), k) → cons(x, app(l, k))
sum(cons(x, nil)) → cons(x, nil)
sum(cons(x, cons(y, l))) → sum(cons(plus(x, y), l))
sum(app(l, cons(x, cons(y, k)))) → sum(app(l, sum(cons(x, cons(y, k)))))
plus(s(x), s(y)) → s(s(plus(if(gt(x, y), x, y), if(not(gt(x, y)), id(x), id(y)))))
plus(s(x), x) → plus(if(gt(x, x), id(x), id(x)), s(x))
plus(zero, y) → y
plus(id(x), s(y)) → s(plus(x, if(gt(s(y), y), y, s(y))))
id(x) → x
if(true, x, y) → x
if(false, x, y) → y
not(x) → if(x, false, true)
gt(s(x), zero) → true
gt(zero, y) → false
gt(s(x), s(y)) → gt(x, y)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(40) PisEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R) chain.

(41) TRUE