Termination w.r.t. Q proof of /tmp/tmprX8Yxh/list-sum-prod-assoc.xml

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 QDPOrderProof (⇔)

        ↳7 QDP

        ↳8 QDPOrderProof (⇔)

        ↳9 QDP

        ↳10 QDPOrderProof (⇔)

        ↳11 QDP

        ↳12 PisEmptyProof (⇔)

        ↳13 TRUE

    ↳14 QDP

        ↳15 QDPOrderProof (⇔)

        ↳16 QDP

        ↳17 PisEmptyProof (⇔)

        ↳18 TRUE

    ↳19 QDP

        ↳20 QDPOrderProof (⇔)

        ↳21 QDP

        ↳22 QDPOrderProof (⇔)

        ↳23 QDP

        ↳24 PisEmptyProof (⇔)

        ↳25 TRUE

    ↳26 QDP

        ↳27 QDPOrderProof (⇔)

        ↳28 QDP

        ↳29 PisEmptyProof (⇔)

        ↳30 TRUE

(0) Obligation:

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

+(x, 0) → x
+(0, x) → x
+(s(x), s(y)) → s(s(+(x, y)))
+(+(x, y), z) → +(x, +(y, z))
*(x, 0) → 0
*(0, x) → 0
*(s(x), s(y)) → s(+(*(x, y), +(x, y)))
*(*(x, y), z) → *(x, *(y, z))
sum(nil) → 0
sum(cons(x, l)) → +(x, sum(l))
prod(nil) → s(0)
prod(cons(x, l)) → *(x, prod(l))

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:

+¹(s(x), s(y)) → +¹(x, y)
+¹(+(x, y), z) → +¹(x, +(y, z))
+¹(+(x, y), z) → +¹(y, z)
*¹(s(x), s(y)) → +¹(*(x, y), +(x, y))
*¹(s(x), s(y)) → *¹(x, y)
*¹(s(x), s(y)) → +¹(x, y)
*¹(*(x, y), z) → *¹(x, *(y, z))
*¹(*(x, y), z) → *¹(y, z)
SUM(cons(x, l)) → +¹(x, sum(l))
SUM(cons(x, l)) → SUM(l)
PROD(cons(x, l)) → *¹(x, prod(l))
PROD(cons(x, l)) → PROD(l)

The TRS R consists of the following rules:

+(x, 0) → x
+(0, x) → x
+(s(x), s(y)) → s(s(+(x, y)))
+(+(x, y), z) → +(x, +(y, z))
*(x, 0) → 0
*(0, x) → 0
*(s(x), s(y)) → s(+(*(x, y), +(x, y)))
*(*(x, y), z) → *(x, *(y, z))
sum(nil) → 0
sum(cons(x, l)) → +(x, sum(l))
prod(nil) → s(0)
prod(cons(x, l)) → *(x, prod(l))

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

(4) Complex Obligation (AND)

(5) Obligation:

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

+¹(+(x, y), z) → +¹(x, +(y, z))
+¹(s(x), s(y)) → +¹(x, y)
+¹(+(x, y), z) → +¹(y, z)

The TRS R consists of the following rules:

+(x, 0) → x
+(0, x) → x
+(s(x), s(y)) → s(s(+(x, y)))
+(+(x, y), z) → +(x, +(y, z))
*(x, 0) → 0
*(0, x) → 0
*(s(x), s(y)) → s(+(*(x, y), +(x, y)))
*(*(x, y), z) → *(x, *(y, z))
sum(nil) → 0
sum(cons(x, l)) → +(x, sum(l))
prod(nil) → s(0)
prod(cons(x, l)) → *(x, prod(l))

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

(6) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

+¹(s(x), s(y)) → +¹(x, y)

The remaining pairs can at least be oriented weakly.
Used ordering: SCNP Order with the following components:
Level mapping:
Top level AFS:
+¹(x0, x1, x2) = +¹(x1)

Tags:
+¹ has argument tags [2,0,2] and root tag 0

Comparison: MAX
Underlying order for the size change arcs and the rules of R:
Polynomial interpretation [POLO]:

POL(+(x₁, x₂)) = x₁ + x₂
POL(+¹(x₁, x₂)) = 1
POL(0) = 0
POL(s(x₁)) = 1 + x₁

The following usable rules [FROCOS05] were oriented: none

(7) Obligation:

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

+¹(+(x, y), z) → +¹(x, +(y, z))
+¹(+(x, y), z) → +¹(y, z)

The TRS R consists of the following rules:

+(x, 0) → x
+(0, x) → x
+(s(x), s(y)) → s(s(+(x, y)))
+(+(x, y), z) → +(x, +(y, z))
*(x, 0) → 0
*(0, x) → 0
*(s(x), s(y)) → s(+(*(x, y), +(x, y)))
*(*(x, y), z) → *(x, *(y, z))
sum(nil) → 0
sum(cons(x, l)) → +(x, sum(l))
prod(nil) → s(0)
prod(cons(x, l)) → *(x, prod(l))

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

(8) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

+¹(+(x, y), z) → +¹(y, z)

The remaining pairs can at least be oriented weakly.
Used ordering: SCNP Order with the following components:
Level mapping:
Top level AFS:
+¹(x0, x1, x2) = +¹(x0)

Tags:
+¹ has argument tags [1,1,2] and root tag 0

Comparison: MAX
Underlying order for the size change arcs and the rules of R:
Polynomial interpretation [POLO]:

POL(+(x₁, x₂)) = 1 + x₁ + x₂
POL(+¹(x₁, x₂)) = x₁ + x₂
POL(0) = 0
POL(s(x₁)) = 1

The following usable rules [FROCOS05] were oriented:

+(x, 0) → x
+(0, x) → x
+(s(x), s(y)) → s(s(+(x, y)))
+(+(x, y), z) → +(x, +(y, z))

(9) Obligation:

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

+¹(+(x, y), z) → +¹(x, +(y, z))

The TRS R consists of the following rules:

+(x, 0) → x
+(0, x) → x
+(s(x), s(y)) → s(s(+(x, y)))
+(+(x, y), z) → +(x, +(y, z))
*(x, 0) → 0
*(0, x) → 0
*(s(x), s(y)) → s(+(*(x, y), +(x, y)))
*(*(x, y), z) → *(x, *(y, z))
sum(nil) → 0
sum(cons(x, l)) → +(x, sum(l))
prod(nil) → s(0)
prod(cons(x, l)) → *(x, prod(l))

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

(10) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

+¹(+(x, y), z) → +¹(x, +(y, z))

The remaining pairs can at least be oriented weakly.
Used ordering: SCNP Order with the following components:
Level mapping:
Top level AFS:
+¹(x0, x1, x2) = +¹(x1)

Tags:
+¹ has argument tags [1,1,3] and root tag 0

Comparison: MAX
Underlying order for the size change arcs and the rules of R:
Polynomial interpretation [POLO]:

POL(+(x₁, x₂)) = 1 + x₁
POL(+¹(x₁, x₂)) = 1
POL(0) = 0
POL(s(x₁)) = 0

The following usable rules [FROCOS05] were oriented: none

(11) Obligation:

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

+(x, 0) → x
+(0, x) → x
+(s(x), s(y)) → s(s(+(x, y)))
+(+(x, y), z) → +(x, +(y, z))
*(x, 0) → 0
*(0, x) → 0
*(s(x), s(y)) → s(+(*(x, y), +(x, y)))
*(*(x, y), z) → *(x, *(y, z))
sum(nil) → 0
sum(cons(x, l)) → +(x, sum(l))
prod(nil) → s(0)
prod(cons(x, l)) → *(x, prod(l))

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

(12) PisEmptyProof (EQUIVALENT transformation)

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

(13) TRUE

(14) Obligation:

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

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

The TRS R consists of the following rules:

+(x, 0) → x
+(0, x) → x
+(s(x), s(y)) → s(s(+(x, y)))
+(+(x, y), z) → +(x, +(y, z))
*(x, 0) → 0
*(0, x) → 0
*(s(x), s(y)) → s(+(*(x, y), +(x, y)))
*(*(x, y), z) → *(x, *(y, z))
sum(nil) → 0
sum(cons(x, l)) → +(x, sum(l))
prod(nil) → s(0)
prod(cons(x, l)) → *(x, prod(l))

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

(15) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

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

The remaining pairs can at least be oriented weakly.
Used ordering: SCNP Order with the following components:
Level mapping:
Top level AFS:
SUM(x0, x1) = SUM(x1)

Tags:
SUM has argument tags [1,1] and root tag 0

Comparison: MAX
Underlying order for the size change arcs and the rules of R:
Polynomial interpretation [POLO]:

POL(SUM(x₁)) = 0
POL(cons(x₁, x₂)) = 1 + x₂

The following usable rules [FROCOS05] were oriented: none

(16) Obligation:

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

+(x, 0) → x
+(0, x) → x
+(s(x), s(y)) → s(s(+(x, y)))
+(+(x, y), z) → +(x, +(y, z))
*(x, 0) → 0
*(0, x) → 0
*(s(x), s(y)) → s(+(*(x, y), +(x, y)))
*(*(x, y), z) → *(x, *(y, z))
sum(nil) → 0
sum(cons(x, l)) → +(x, sum(l))
prod(nil) → s(0)
prod(cons(x, l)) → *(x, prod(l))

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

(17) PisEmptyProof (EQUIVALENT transformation)

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

(18) TRUE

(19) Obligation:

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

*¹(*(x, y), z) → *¹(x, *(y, z))
*¹(s(x), s(y)) → *¹(x, y)
*¹(*(x, y), z) → *¹(y, z)

The TRS R consists of the following rules:

+(x, 0) → x
+(0, x) → x
+(s(x), s(y)) → s(s(+(x, y)))
+(+(x, y), z) → +(x, +(y, z))
*(x, 0) → 0
*(0, x) → 0
*(s(x), s(y)) → s(+(*(x, y), +(x, y)))
*(*(x, y), z) → *(x, *(y, z))
sum(nil) → 0
sum(cons(x, l)) → +(x, sum(l))
prod(nil) → s(0)
prod(cons(x, l)) → *(x, prod(l))

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.

*¹(s(x), s(y)) → *¹(x, y)

The remaining pairs can at least be oriented weakly.
Used ordering: SCNP Order with the following components:
Level mapping:
Top level AFS:
*¹(x0, x1, x2) = *¹(x0)

Tags:
*¹ has argument tags [1,3,0] and root tag 0

Comparison: MAX
Underlying order for the size change arcs and the rules of R:
Polynomial interpretation [POLO]:

POL(*(x₁, x₂)) = x₁ + x₂
POL(*¹(x₁, x₂)) = x₁
POL(+(x₁, x₂)) = 1 + x₁ + x₂
POL(0) = 0
POL(s(x₁)) = 1 + x₁

The following usable rules [FROCOS05] were oriented: none

(21) Obligation:

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

*¹(*(x, y), z) → *¹(x, *(y, z))
*¹(*(x, y), z) → *¹(y, z)

The TRS R consists of the following rules:

+(x, 0) → x
+(0, x) → x
+(s(x), s(y)) → s(s(+(x, y)))
+(+(x, y), z) → +(x, +(y, z))
*(x, 0) → 0
*(0, x) → 0
*(s(x), s(y)) → s(+(*(x, y), +(x, y)))
*(*(x, y), z) → *(x, *(y, z))
sum(nil) → 0
sum(cons(x, l)) → +(x, sum(l))
prod(nil) → s(0)
prod(cons(x, l)) → *(x, prod(l))

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

(22) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

*¹(*(x, y), z) → *¹(x, *(y, z))
*¹(*(x, y), z) → *¹(y, z)

The remaining pairs can at least be oriented weakly.
Used ordering: SCNP Order with the following components:
Level mapping:
Top level AFS:
*¹(x0, x1, x2) = *¹(x1)

Tags:
*¹ has argument tags [2,0,2] and root tag 0

Comparison: MAX
Underlying order for the size change arcs and the rules of R:
Polynomial interpretation [POLO]:

POL(*(x₁, x₂)) = 1 + x₁ + x₂
POL(*¹(x₁, x₂)) = x₂
POL(+(x₁, x₂)) = 1 + x₂
POL(0) = 0
POL(s(x₁)) = 0

The following usable rules [FROCOS05] were oriented:

*(x, 0) → 0
*(0, x) → 0
*(s(x), s(y)) → s(+(*(x, y), +(x, y)))
*(*(x, y), z) → *(x, *(y, z))

(23) Obligation:

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

+(x, 0) → x
+(0, x) → x
+(s(x), s(y)) → s(s(+(x, y)))
+(+(x, y), z) → +(x, +(y, z))
*(x, 0) → 0
*(0, x) → 0
*(s(x), s(y)) → s(+(*(x, y), +(x, y)))
*(*(x, y), z) → *(x, *(y, z))
sum(nil) → 0
sum(cons(x, l)) → +(x, sum(l))
prod(nil) → s(0)
prod(cons(x, l)) → *(x, prod(l))

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

(24) PisEmptyProof (EQUIVALENT transformation)

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

(25) TRUE

(26) Obligation:

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

PROD(cons(x, l)) → PROD(l)

The TRS R consists of the following rules:

+(x, 0) → x
+(0, x) → x
+(s(x), s(y)) → s(s(+(x, y)))
+(+(x, y), z) → +(x, +(y, z))
*(x, 0) → 0
*(0, x) → 0
*(s(x), s(y)) → s(+(*(x, y), +(x, y)))
*(*(x, y), z) → *(x, *(y, z))
sum(nil) → 0
sum(cons(x, l)) → +(x, sum(l))
prod(nil) → s(0)
prod(cons(x, l)) → *(x, prod(l))

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

(27) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

PROD(cons(x, l)) → PROD(l)

The remaining pairs can at least be oriented weakly.
Used ordering: SCNP Order with the following components:
Level mapping:
Top level AFS:
PROD(x0, x1) = PROD(x1)

Tags:
PROD has argument tags [1,1] and root tag 0

Comparison: MAX
Underlying order for the size change arcs and the rules of R:
Polynomial interpretation [POLO]:

POL(PROD(x₁)) = 0
POL(cons(x₁, x₂)) = 1 + x₂

The following usable rules [FROCOS05] were oriented: none

(28) Obligation:

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

+(x, 0) → x
+(0, x) → x
+(s(x), s(y)) → s(s(+(x, y)))
+(+(x, y), z) → +(x, +(y, z))
*(x, 0) → 0
*(0, x) → 0
*(s(x), s(y)) → s(+(*(x, y), +(x, y)))
*(*(x, y), z) → *(x, *(y, z))
sum(nil) → 0
sum(cons(x, l)) → +(x, sum(l))
prod(nil) → s(0)
prod(cons(x, l)) → *(x, prod(l))

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

(29) PisEmptyProof (EQUIVALENT transformation)

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

(0) Obligation:

(1) DependencyPairsProof (EQUIVALENT transformation)

(2) Obligation:

(3) DependencyGraphProof (EQUIVALENT transformation)

(4) Complex Obligation (AND)

(5) Obligation:

(6) QDPOrderProof (EQUIVALENT transformation)

(7) Obligation:

(8) QDPOrderProof (EQUIVALENT transformation)

(9) Obligation:

(10) QDPOrderProof (EQUIVALENT transformation)

(11) Obligation:

(12) PisEmptyProof (EQUIVALENT transformation)

(13) TRUE

(14) Obligation:

(15) QDPOrderProof (EQUIVALENT transformation)

(16) Obligation:

(17) PisEmptyProof (EQUIVALENT transformation)

(18) TRUE

(19) Obligation:

(20) QDPOrderProof (EQUIVALENT transformation)

(21) Obligation:

(22) QDPOrderProof (EQUIVALENT transformation)

(23) Obligation:

(24) PisEmptyProof (EQUIVALENT transformation)

(25) TRUE

(26) Obligation:

(27) QDPOrderProof (EQUIVALENT transformation)

(28) Obligation:

(29) PisEmptyProof (EQUIVALENT transformation)

(30) TRUE