Termination Proof using AProVE

Term Rewriting System R:
[m, n, x, k]
eq(0, 0) -> true
eq(0, s(m)) -> false
eq(s(n), 0) -> false
eq(s(n), s(m)) -> eq(n, m)
le(0, m) -> true
le(s(n), 0) -> false
le(s(n), s(m)) -> le(n, m)
min(cons(0, nil)) -> 0
min(cons(s(n), nil)) -> s(n)
min(cons(n, cons(m, x))) -> if_min(le(n, m), cons(n, cons(m, x)))
if_min(true, cons(n, cons(m, x))) -> min(cons(n, x))
if_min(false, cons(n, cons(m, x))) -> min(cons(m, x))
replace(n, m, nil) -> nil
replace(n, m, cons(k, x)) -> if_replace(eq(n, k), n, m, cons(k, x))
if_replace(true, n, m, cons(k, x)) -> cons(m, x)
if_replace(false, n, m, cons(k, x)) -> cons(k, replace(n, m, x))
sort(nil) -> nil
sort(cons(n, x)) -> cons(min(cons(n, x)), sort(replace(min(cons(n, x)), n, x)))

Innermost Termination of R to be shown.

     ↳Dependency Pair Analysis

R contains the following Dependency Pairs:

EQ(s(n), s(m)) -> EQ(n, m)
LE(s(n), s(m)) -> LE(n, m)
MIN(cons(n, cons(m, x))) -> IF_MIN(le(n, m), cons(n, cons(m, x)))
MIN(cons(n, cons(m, x))) -> LE(n, m)
IF_MIN(true, cons(n, cons(m, x))) -> MIN(cons(n, x))
IF_MIN(false, cons(n, cons(m, x))) -> MIN(cons(m, x))
REPLACE(n, m, cons(k, x)) -> IF_REPLACE(eq(n, k), n, m, cons(k, x))
REPLACE(n, m, cons(k, x)) -> EQ(n, k)
IF_REPLACE(false, n, m, cons(k, x)) -> REPLACE(n, m, x)
SORT(cons(n, x)) -> MIN(cons(n, x))
SORT(cons(n, x)) -> SORT(replace(min(cons(n, x)), n, x))
SORT(cons(n, x)) -> REPLACE(min(cons(n, x)), n, x)

Furthermore, R contains five SCCs.

     ↳DPs

       →DP Problem 1

         ↳Polynomial Ordering

       →DP Problem 2

         ↳Polo

       →DP Problem 3

         ↳Polo

       →DP Problem 4

         ↳Polo

       →DP Problem 5

         ↳Polo

Dependency Pair:

EQ(s(n), s(m)) -> EQ(n, m)

Rules:

eq(0, 0) -> true
eq(0, s(m)) -> false
eq(s(n), 0) -> false
eq(s(n), s(m)) -> eq(n, m)
le(0, m) -> true
le(s(n), 0) -> false
le(s(n), s(m)) -> le(n, m)
min(cons(0, nil)) -> 0
min(cons(s(n), nil)) -> s(n)
min(cons(n, cons(m, x))) -> if_min(le(n, m), cons(n, cons(m, x)))
if_min(true, cons(n, cons(m, x))) -> min(cons(n, x))
if_min(false, cons(n, cons(m, x))) -> min(cons(m, x))
replace(n, m, nil) -> nil
replace(n, m, cons(k, x)) -> if_replace(eq(n, k), n, m, cons(k, x))
if_replace(true, n, m, cons(k, x)) -> cons(m, x)
if_replace(false, n, m, cons(k, x)) -> cons(k, replace(n, m, x))
sort(nil) -> nil
sort(cons(n, x)) -> cons(min(cons(n, x)), sort(replace(min(cons(n, x)), n, x)))

Strategy:

innermost

The following dependency pair can be strictly oriented:

EQ(s(n), s(m)) -> EQ(n, m)

There are no usable rules for innermost w.r.t. to the implicit AFS that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(EQ(x₁, x₂)) = x₁

POL(s(x₁)) = 1 + x₁

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳Polo

           →DP Problem 6

             ↳Dependency Graph

       →DP Problem 2

         ↳Polo

       →DP Problem 3

         ↳Polo

       →DP Problem 4

         ↳Polo

       →DP Problem 5

         ↳Polo

Dependency Pair:

Rules:

eq(0, 0) -> true
eq(0, s(m)) -> false
eq(s(n), 0) -> false
eq(s(n), s(m)) -> eq(n, m)
le(0, m) -> true
le(s(n), 0) -> false
le(s(n), s(m)) -> le(n, m)
min(cons(0, nil)) -> 0
min(cons(s(n), nil)) -> s(n)
min(cons(n, cons(m, x))) -> if_min(le(n, m), cons(n, cons(m, x)))
if_min(true, cons(n, cons(m, x))) -> min(cons(n, x))
if_min(false, cons(n, cons(m, x))) -> min(cons(m, x))
replace(n, m, nil) -> nil
replace(n, m, cons(k, x)) -> if_replace(eq(n, k), n, m, cons(k, x))
if_replace(true, n, m, cons(k, x)) -> cons(m, x)
if_replace(false, n, m, cons(k, x)) -> cons(k, replace(n, m, x))
sort(nil) -> nil
sort(cons(n, x)) -> cons(min(cons(n, x)), sort(replace(min(cons(n, x)), n, x)))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳Polo

       →DP Problem 2

         ↳Polynomial Ordering

       →DP Problem 3

         ↳Polo

       →DP Problem 4

         ↳Polo

       →DP Problem 5

         ↳Polo

Dependency Pair:

LE(s(n), s(m)) -> LE(n, m)

Rules:

eq(0, 0) -> true
eq(0, s(m)) -> false
eq(s(n), 0) -> false
eq(s(n), s(m)) -> eq(n, m)
le(0, m) -> true
le(s(n), 0) -> false
le(s(n), s(m)) -> le(n, m)
min(cons(0, nil)) -> 0
min(cons(s(n), nil)) -> s(n)
min(cons(n, cons(m, x))) -> if_min(le(n, m), cons(n, cons(m, x)))
if_min(true, cons(n, cons(m, x))) -> min(cons(n, x))
if_min(false, cons(n, cons(m, x))) -> min(cons(m, x))
replace(n, m, nil) -> nil
replace(n, m, cons(k, x)) -> if_replace(eq(n, k), n, m, cons(k, x))
if_replace(true, n, m, cons(k, x)) -> cons(m, x)
if_replace(false, n, m, cons(k, x)) -> cons(k, replace(n, m, x))
sort(nil) -> nil
sort(cons(n, x)) -> cons(min(cons(n, x)), sort(replace(min(cons(n, x)), n, x)))

Strategy:

innermost

The following dependency pair can be strictly oriented:

LE(s(n), s(m)) -> LE(n, m)

There are no usable rules for innermost w.r.t. to the implicit AFS that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(LE(x₁, x₂)) = x₁

POL(s(x₁)) = 1 + x₁

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳Polo

       →DP Problem 2

         ↳Polo

           →DP Problem 7

             ↳Dependency Graph

       →DP Problem 3

         ↳Polo

       →DP Problem 4

         ↳Polo

       →DP Problem 5

         ↳Polo

Dependency Pair:

Rules:

eq(0, 0) -> true
eq(0, s(m)) -> false
eq(s(n), 0) -> false
eq(s(n), s(m)) -> eq(n, m)
le(0, m) -> true
le(s(n), 0) -> false
le(s(n), s(m)) -> le(n, m)
min(cons(0, nil)) -> 0
min(cons(s(n), nil)) -> s(n)
min(cons(n, cons(m, x))) -> if_min(le(n, m), cons(n, cons(m, x)))
if_min(true, cons(n, cons(m, x))) -> min(cons(n, x))
if_min(false, cons(n, cons(m, x))) -> min(cons(m, x))
replace(n, m, nil) -> nil
replace(n, m, cons(k, x)) -> if_replace(eq(n, k), n, m, cons(k, x))
if_replace(true, n, m, cons(k, x)) -> cons(m, x)
if_replace(false, n, m, cons(k, x)) -> cons(k, replace(n, m, x))
sort(nil) -> nil
sort(cons(n, x)) -> cons(min(cons(n, x)), sort(replace(min(cons(n, x)), n, x)))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳Polo

       →DP Problem 2

         ↳Polo

       →DP Problem 3

         ↳Polynomial Ordering

       →DP Problem 4

         ↳Polo

       →DP Problem 5

         ↳Polo

Dependency Pairs:

IF_REPLACE(false, n, m, cons(k, x)) -> REPLACE(n, m, x)
REPLACE(n, m, cons(k, x)) -> IF_REPLACE(eq(n, k), n, m, cons(k, x))

Rules:

eq(0, 0) -> true
eq(0, s(m)) -> false
eq(s(n), 0) -> false
eq(s(n), s(m)) -> eq(n, m)
le(0, m) -> true
le(s(n), 0) -> false
le(s(n), s(m)) -> le(n, m)
min(cons(0, nil)) -> 0
min(cons(s(n), nil)) -> s(n)
min(cons(n, cons(m, x))) -> if_min(le(n, m), cons(n, cons(m, x)))
if_min(true, cons(n, cons(m, x))) -> min(cons(n, x))
if_min(false, cons(n, cons(m, x))) -> min(cons(m, x))
replace(n, m, nil) -> nil
replace(n, m, cons(k, x)) -> if_replace(eq(n, k), n, m, cons(k, x))
if_replace(true, n, m, cons(k, x)) -> cons(m, x)
if_replace(false, n, m, cons(k, x)) -> cons(k, replace(n, m, x))
sort(nil) -> nil
sort(cons(n, x)) -> cons(min(cons(n, x)), sort(replace(min(cons(n, x)), n, x)))

Strategy:

innermost

The following dependency pair can be strictly oriented:

IF_REPLACE(false, n, m, cons(k, x)) -> REPLACE(n, m, x)

There are no usable rules for innermost w.r.t. to the implicit AFS that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(REPLACE(x₁, x₂, x₃)) = x₃

POL(eq(x₁, x₂)) = 0

POL(0) = 0

POL(false) = 0

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

POL(IF_REPLACE(x₁, x₂, x₃, x₄)) = x₄

POL(true) = 0

POL(s(x₁)) = 0

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳Polo

       →DP Problem 2

         ↳Polo

       →DP Problem 3

         ↳Polo

           →DP Problem 8

             ↳Dependency Graph

       →DP Problem 4

         ↳Polo

       →DP Problem 5

         ↳Polo

Dependency Pair:

REPLACE(n, m, cons(k, x)) -> IF_REPLACE(eq(n, k), n, m, cons(k, x))

Rules:

eq(0, 0) -> true
eq(0, s(m)) -> false
eq(s(n), 0) -> false
eq(s(n), s(m)) -> eq(n, m)
le(0, m) -> true
le(s(n), 0) -> false
le(s(n), s(m)) -> le(n, m)
min(cons(0, nil)) -> 0
min(cons(s(n), nil)) -> s(n)
min(cons(n, cons(m, x))) -> if_min(le(n, m), cons(n, cons(m, x)))
if_min(true, cons(n, cons(m, x))) -> min(cons(n, x))
if_min(false, cons(n, cons(m, x))) -> min(cons(m, x))
replace(n, m, nil) -> nil
replace(n, m, cons(k, x)) -> if_replace(eq(n, k), n, m, cons(k, x))
if_replace(true, n, m, cons(k, x)) -> cons(m, x)
if_replace(false, n, m, cons(k, x)) -> cons(k, replace(n, m, x))
sort(nil) -> nil
sort(cons(n, x)) -> cons(min(cons(n, x)), sort(replace(min(cons(n, x)), n, x)))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳Polo

       →DP Problem 2

         ↳Polo

       →DP Problem 3

         ↳Polo

       →DP Problem 4

         ↳Polynomial Ordering

       →DP Problem 5

         ↳Polo

Dependency Pairs:

IF_MIN(false, cons(n, cons(m, x))) -> MIN(cons(m, x))
IF_MIN(true, cons(n, cons(m, x))) -> MIN(cons(n, x))
MIN(cons(n, cons(m, x))) -> IF_MIN(le(n, m), cons(n, cons(m, x)))

Rules:

eq(0, 0) -> true
eq(0, s(m)) -> false
eq(s(n), 0) -> false
eq(s(n), s(m)) -> eq(n, m)
le(0, m) -> true
le(s(n), 0) -> false
le(s(n), s(m)) -> le(n, m)
min(cons(0, nil)) -> 0
min(cons(s(n), nil)) -> s(n)
min(cons(n, cons(m, x))) -> if_min(le(n, m), cons(n, cons(m, x)))
if_min(true, cons(n, cons(m, x))) -> min(cons(n, x))
if_min(false, cons(n, cons(m, x))) -> min(cons(m, x))
replace(n, m, nil) -> nil
replace(n, m, cons(k, x)) -> if_replace(eq(n, k), n, m, cons(k, x))
if_replace(true, n, m, cons(k, x)) -> cons(m, x)
if_replace(false, n, m, cons(k, x)) -> cons(k, replace(n, m, x))
sort(nil) -> nil
sort(cons(n, x)) -> cons(min(cons(n, x)), sort(replace(min(cons(n, x)), n, x)))

Strategy:

innermost

The following dependency pairs can be strictly oriented:

IF_MIN(false, cons(n, cons(m, x))) -> MIN(cons(m, x))
IF_MIN(true, cons(n, cons(m, x))) -> MIN(cons(n, x))

There are no usable rules for innermost w.r.t. to the implicit AFS that need to be oriented.

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(0) = 0

POL(false) = 0

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

POL(MIN(x₁)) = x₁

POL(true) = 0

POL(s(x₁)) = 0

POL(IF_MIN(x₁, x₂)) = x₂

POL(le(x₁, x₂)) = 0

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳Polo

       →DP Problem 2

         ↳Polo

       →DP Problem 3

         ↳Polo

       →DP Problem 4

         ↳Polo

           →DP Problem 9

             ↳Dependency Graph

       →DP Problem 5

         ↳Polo

Dependency Pair:

MIN(cons(n, cons(m, x))) -> IF_MIN(le(n, m), cons(n, cons(m, x)))

Rules:

eq(0, 0) -> true
eq(0, s(m)) -> false
eq(s(n), 0) -> false
eq(s(n), s(m)) -> eq(n, m)
le(0, m) -> true
le(s(n), 0) -> false
le(s(n), s(m)) -> le(n, m)
min(cons(0, nil)) -> 0
min(cons(s(n), nil)) -> s(n)
min(cons(n, cons(m, x))) -> if_min(le(n, m), cons(n, cons(m, x)))
if_min(true, cons(n, cons(m, x))) -> min(cons(n, x))
if_min(false, cons(n, cons(m, x))) -> min(cons(m, x))
replace(n, m, nil) -> nil
replace(n, m, cons(k, x)) -> if_replace(eq(n, k), n, m, cons(k, x))
if_replace(true, n, m, cons(k, x)) -> cons(m, x)
if_replace(false, n, m, cons(k, x)) -> cons(k, replace(n, m, x))
sort(nil) -> nil
sort(cons(n, x)) -> cons(min(cons(n, x)), sort(replace(min(cons(n, x)), n, x)))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳Polo

       →DP Problem 2

         ↳Polo

       →DP Problem 3

         ↳Polo

       →DP Problem 4

         ↳Polo

       →DP Problem 5

         ↳Polynomial Ordering

Dependency Pair:

SORT(cons(n, x)) -> SORT(replace(min(cons(n, x)), n, x))

Rules:

eq(0, 0) -> true
eq(0, s(m)) -> false
eq(s(n), 0) -> false
eq(s(n), s(m)) -> eq(n, m)
le(0, m) -> true
le(s(n), 0) -> false
le(s(n), s(m)) -> le(n, m)
min(cons(0, nil)) -> 0
min(cons(s(n), nil)) -> s(n)
min(cons(n, cons(m, x))) -> if_min(le(n, m), cons(n, cons(m, x)))
if_min(true, cons(n, cons(m, x))) -> min(cons(n, x))
if_min(false, cons(n, cons(m, x))) -> min(cons(m, x))
replace(n, m, nil) -> nil
replace(n, m, cons(k, x)) -> if_replace(eq(n, k), n, m, cons(k, x))
if_replace(true, n, m, cons(k, x)) -> cons(m, x)
if_replace(false, n, m, cons(k, x)) -> cons(k, replace(n, m, x))
sort(nil) -> nil
sort(cons(n, x)) -> cons(min(cons(n, x)), sort(replace(min(cons(n, x)), n, x)))

Strategy:

innermost

The following dependency pair can be strictly oriented:

SORT(cons(n, x)) -> SORT(replace(min(cons(n, x)), n, x))

Additionally, the following usable rules for innermost w.r.t. to the implicit AFS can be oriented:

replace(n, m, nil) -> nil
replace(n, m, cons(k, x)) -> if_replace(eq(n, k), n, m, cons(k, x))
if_replace(true, n, m, cons(k, x)) -> cons(m, x)
if_replace(false, n, m, cons(k, x)) -> cons(k, replace(n, m, x))

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(false) = 0

POL(true) = 0

POL(replace(x₁, x₂, x₃)) = x₃

POL(if_min(x₁, x₂)) = 0

POL(SORT(x₁)) = x₁

POL(0) = 0

POL(eq(x₁, x₂)) = 0

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

POL(min(x₁)) = 0

POL(nil) = 0

POL(s(x₁)) = 0

POL(le(x₁, x₂)) = 0

POL(if_replace(x₁, x₂, x₃, x₄)) = x₄

resulting in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳Polo

       →DP Problem 2

         ↳Polo

       →DP Problem 3

         ↳Polo

       →DP Problem 4

         ↳Polo

       →DP Problem 5

         ↳Polo

           →DP Problem 10

             ↳Dependency Graph

Dependency Pair:

Rules:

eq(0, 0) -> true
eq(0, s(m)) -> false
eq(s(n), 0) -> false
eq(s(n), s(m)) -> eq(n, m)
le(0, m) -> true
le(s(n), 0) -> false
le(s(n), s(m)) -> le(n, m)
min(cons(0, nil)) -> 0
min(cons(s(n), nil)) -> s(n)
min(cons(n, cons(m, x))) -> if_min(le(n, m), cons(n, cons(m, x)))
if_min(true, cons(n, cons(m, x))) -> min(cons(n, x))
if_min(false, cons(n, cons(m, x))) -> min(cons(m, x))
replace(n, m, nil) -> nil
replace(n, m, cons(k, x)) -> if_replace(eq(n, k), n, m, cons(k, x))
if_replace(true, n, m, cons(k, x)) -> cons(m, x)
if_replace(false, n, m, cons(k, x)) -> cons(k, replace(n, m, x))
sort(nil) -> nil
sort(cons(n, x)) -> cons(min(cons(n, x)), sort(replace(min(cons(n, x)), n, x)))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

Innermost Termination of R successfully shown.
Duration:
0:00 minutes

POL(REPLACE(x₁, x₂, x₃))	= x₃
POL(eq(x₁, x₂))	= 0
POL(0)	= 0
POL(false)	= 0
POL(cons(x₁, x₂))	= 1 + x₂
POL(IF_REPLACE(x₁, x₂, x₃, x₄))	= x₄
POL(true)	= 0
POL(s(x₁))	= 0