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 UsableRulesProof (⇔)
    ↳17 QDP
    ↳18 MNOCProof (⇔)
    ↳19 QDP
    ↳20 UsableRulesReductionPairsProof (⇔)
    ↳21 QDP
    ↳22 PisEmptyProof (⇔)
    ↳23 TRUE
  ↳24 QDP
    ↳25 UsableRulesProof (⇔)
    ↳26 QDP
    ↳27 UsableRulesReductionPairsProof (⇔)
    ↳28 QDP
    ↳29 MRRProof (⇔)
    ↳30 QDP
    ↳31 UsableRulesProof (⇔)
    ↳32 QDP
    ↳33 MRRProof (⇔)
    ↳34 QDP
    ↳35 DependencyGraphProof (⇔)
    ↳36 TRUE
  ↳37 QDP
    ↳38 UsableRulesProof (⇔)
    ↳39 QDP
    ↳40 MNOCProof (⇔)
    ↳41 QDP
    ↳42 QDPSizeChangeProof (⇔)
    ↳43 TRUE
  ↳44 QDP
    ↳45 QDPOrderProof (⇔)
    ↳46 QDP
    ↳47 PisEmptyProof (⇔)
    ↳48 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)))))

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)))

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)))))

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 6 SCCs with 5 less nodes.

(4) Complex Obligation (AND)

(5) 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)))))

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:

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

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:

  • APP(cons(x, l), k) → APP(l, k)
    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:

PLUS(s(x), y) → PLUS(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)))))

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:

PLUS(s(x), y) → PLUS(x, y)

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:

  • PLUS(s(x), y) → PLUS(x, y)
    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:

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)))))

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

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

(17) 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:

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

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

(18) MNOCProof (EQUIVALENT transformation)

We use the modular non-overlap check [LPAR04] to enlarge Q to all left-hand sides of R.

(19) 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:

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

The set Q consists of the following terms:

plus(0, x0)
plus(s(x0), x1)

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

(20) UsableRulesReductionPairsProof (EQUIVALENT transformation)

By using the usable rules with reduction pair processor [LPAR04] with a polynomial ordering [POLO], all dependency pairs and the corresponding usable rules [FROCOS05] can be oriented non-strictly. All non-usable rules are removed, and those dependency pairs and usable rules that have been oriented strictly or contain non-usable symbols in their left-hand side are removed as well.

The following dependency pairs can be deleted:

SUM(cons(x, cons(y, l))) → SUM(cons(plus(x, y), l))
The following rules are removed from R:

plus(0, y) → y
Used ordering: POLO with Polynomial interpretation [POLO]:

POL(0) = 0   
POL(SUM(x1)) = 2·x1   
POL(cons(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(plus(x1, x2)) = x1 + x2   
POL(s(x1)) = x1   

(21) Obligation:

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

plus(s(x), y) → s(plus(x, y))

The set Q consists of the following terms:

plus(0, x0)
plus(s(x0), x1)

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

(22) PisEmptyProof (EQUIVALENT transformation)

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

(23) TRUE

(24) 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)))))

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

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

(26) 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:

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

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

(27) UsableRulesReductionPairsProof (EQUIVALENT transformation)

By using the usable rules with reduction pair processor [LPAR04] with a polynomial ordering [POLO], all dependency pairs and the corresponding usable rules [FROCOS05] can be oriented non-strictly. All non-usable rules are removed, and those dependency pairs and usable rules that have been oriented strictly or contain non-usable symbols in their left-hand side are removed as well.

No dependency pairs are removed.

The following rules are removed from R:

app(nil, k) → k
app(l, nil) → l
plus(0, y) → y
Used ordering: POLO with Polynomial interpretation [POLO]:

POL(0) = 0   
POL(SUM(x1)) = x1   
POL(app(x1, x2)) = 2 + 2·x1 + x2   
POL(cons(x1, x2)) = 2·x1 + x2   
POL(nil) = 0   
POL(plus(x1, x2)) = x1 + x2   
POL(s(x1)) = x1   
POL(sum(x1)) = x1   

(28) 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:

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

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

(29) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.

Strictly oriented rules of the TRS R:

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

Used ordering: Polynomial interpretation [POLO]:

POL(SUM(x1)) = x1   
POL(app(x1, x2)) = x1 + x2   
POL(cons(x1, x2)) = 1 + x1 + x2   
POL(nil) = 0   
POL(plus(x1, x2)) = x1 + x2   
POL(s(x1)) = x1   
POL(sum(x1)) = x1   

(30) 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:

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

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

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

(32) 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:

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

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

(33) MRRProof (EQUIVALENT transformation)

By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.

Strictly oriented rules of the TRS R:

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

Used ordering: Polynomial interpretation [POLO]:

POL(SUM(x1)) = 2·x1   
POL(app(x1, x2)) = 2·x1 + 2·x2   
POL(cons(x1, x2)) = 2 + x1 + x2   
POL(sum(x1)) = x1   

(34) 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)))))

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

(35) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(36) TRUE

(37) 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)))))

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

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

(39) 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:

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

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

(40) MNOCProof (EQUIVALENT transformation)

We use the modular non-overlap check [LPAR04] to enlarge Q to all left-hand sides of R.

(41) 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:

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

The set Q consists of the following terms:

plus(0, x0)
plus(s(x0), x1)

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

(42) 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

(43) TRUE

(44) 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)))))

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

(45) 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(minus(x1, x2)) = x1   
POL(plus(x1, x2)) = 0   
POL(s(x1)) = 1 + x1   

The following usable rules [FROCOS05] were oriented:

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

(46) 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)))))

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

(47) PisEmptyProof (EQUIVALENT transformation)

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

(48) TRUE