Termination Proof using AProVE

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

Innermost Termination of R to be shown.

     ↳Dependency Pair Analysis

R contains the following Dependency Pairs:

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

Furthermore, R contains five SCCs.

     ↳DPs

       →DP Problem 1

         ↳Usable Rules (Innermost)

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

Dependency Pair:

APP(app(eq, app(s, n)), app(s, m)) -> APP(app(eq, n), m)

Rules:

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

Strategy:

innermost

As we are in the innermost case, we can delete all 18 non-usable-rules.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

           →DP Problem 6

             ↳A-Transformation

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

Dependency Pair:

APP(app(eq, app(s, n)), app(s, m)) -> APP(app(eq, n), m)

Rule:

none

Strategy:

innermost

We have an applicative DP problem with proper arity. Thus we can use the A-Transformation to obtain one new DP problem which consists of the A-transformed TRSs.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

           →DP Problem 6

             ↳ATrans

...

               →DP Problem 7

                 ↳Size-Change Principle

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

Dependency Pair:

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

Rule:

none

Strategy:

innermost

We number the DPs as follows:

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

and get the following Size-Change Graph(s):

{1}	,	{1}
1	>	1
2	>	2

which lead(s) to this/these maximal multigraph(s):

{1}	,	{1}
1	>	1
2	>	2

D_P: empty set
Oriented Rules: none

We used the order Homeomorphic Embedding Order with Non-Strict Precedence.

trivial

with Argument Filtering System:

s(x₁) -> s(x₁)

We obtain no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳Usable Rules (Innermost)

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

Dependency Pair:

APP(app(le, app(s, n)), app(s, m)) -> APP(app(le, n), m)

Rules:

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

Strategy:

innermost

As we are in the innermost case, we can delete all 18 non-usable-rules.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

           →DP Problem 8

             ↳A-Transformation

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

Dependency Pair:

APP(app(le, app(s, n)), app(s, m)) -> APP(app(le, n), m)

Rule:

none

Strategy:

innermost

We have an applicative DP problem with proper arity. Thus we can use the A-Transformation to obtain one new DP problem which consists of the A-transformed TRSs.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

           →DP Problem 8

             ↳ATrans

...

               →DP Problem 9

                 ↳Size-Change Principle

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

Dependency Pair:

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

Rule:

none

Strategy:

innermost

We number the DPs as follows:

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

and get the following Size-Change Graph(s):

{1}	,	{1}
1	>	1
2	>	2

which lead(s) to this/these maximal multigraph(s):

{1}	,	{1}
1	>	1
2	>	2

D_P: empty set
Oriented Rules: none

We used the order Homeomorphic Embedding Order with Non-Strict Precedence.

trivial

with Argument Filtering System:

s(x₁) -> s(x₁)

We obtain no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳Usable Rules (Innermost)

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

Dependency Pairs:

APP(app(app(app(if_replace, false), n), m), app(app(cons, k), x)) -> APP(app(app(replace, n), m), x)
APP(app(app(replace, n), m), app(app(cons, k), x)) -> APP(app(app(app(if_replace, app(app(eq, n), k)), n), m), app(app(cons, k), x))

Rules:

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

Strategy:

innermost

As we are in the innermost case, we can delete all 14 non-usable-rules.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

           →DP Problem 10

             ↳A-Transformation

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

Dependency Pairs:

Rules:

app(app(eq, app(s, n)), 0) -> false
app(app(eq, 0), app(s, m)) -> false
app(app(eq, 0), 0) -> true
app(app(eq, app(s, n)), app(s, m)) -> app(app(eq, n), m)

Strategy:

innermost

We have an applicative DP problem with proper arity. Thus we can use the A-Transformation to obtain one new DP problem which consists of the A-transformed TRSs.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

           →DP Problem 10

             ↳ATrans

...

               →DP Problem 11

                 ↳Size-Change Principle

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

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(s(n), 0) -> false
eq(0, s(m)) -> false
eq(0, 0) -> true
eq(s(n), s(m)) -> eq(n, m)

Strategy:

innermost

We number the DPs as follows:

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

and get the following Size-Change Graph(s):

{1}	,	{1}
2	=	1
3	=	2
4	>	3

{2}	,	{2}
1	=	2
2	=	3
3	=	4

which lead(s) to this/these maximal multigraph(s):

{1}	,	{2}
2	=	2
3	=	3
4	>	4

{2}	,	{1}
1	=	1
2	=	2
3	>	3

D_P: empty set
Oriented Rules: none

We used the order Homeomorphic Embedding Order with Non-Strict Precedence.

trivial

with Argument Filtering System:

cons(x₁, x₂) -> cons(x₁, x₂)

We obtain no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳Usable Rules (Innermost)

       →DP Problem 5

         ↳UsableRules

Dependency Pairs:

APP(app(if_min, false), app(app(cons, n), app(app(cons, m), x))) -> APP(min, app(app(cons, m), x))
APP(app(if_min, true), app(app(cons, n), app(app(cons, m), x))) -> APP(min, app(app(cons, n), x))
APP(min, app(app(cons, n), app(app(cons, m), x))) -> APP(app(if_min, app(app(le, n), m)), app(app(cons, n), app(app(cons, m), x)))

Rules:

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

Strategy:

innermost

As we are in the innermost case, we can delete all 15 non-usable-rules.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

           →DP Problem 12

             ↳A-Transformation

       →DP Problem 5

         ↳UsableRules

Dependency Pairs:

Rules:

app(app(le, 0), m) -> true
app(app(le, app(s, n)), app(s, m)) -> app(app(le, n), m)
app(app(le, app(s, n)), 0) -> false

Strategy:

innermost

We have an applicative DP problem with proper arity. Thus we can use the A-Transformation to obtain one new DP problem which consists of the A-transformed TRSs.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

           →DP Problem 12

             ↳ATrans

...

               →DP Problem 13

                 ↳Size-Change Principle

       →DP Problem 5

         ↳UsableRules

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:

le(0, m) -> true
le(s(n), s(m)) -> le(n, m)
le(s(n), 0) -> false

Strategy:

innermost

We number the DPs as follows:

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

and get the following Size-Change Graph(s):

{1, 2}	,	{1, 2}
2	>	1

{3}	,	{3}
1	=	2

which lead(s) to this/these maximal multigraph(s):

{1, 2}	,	{3}
2	>	2

{3}	,	{1, 2}
1	>	1

D_P: empty set
Oriented Rules: none

We used the order Homeomorphic Embedding Order with Non-Strict Precedence.

trivial

with Argument Filtering System:

cons(x₁, x₂) -> cons(x₁, x₂)

We obtain no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳Usable Rules (Innermost)

Dependency Pair:

APP(sort, app(app(cons, n), x)) -> APP(sort, app(app(app(replace, app(min, app(app(cons, n), x))), n), x))

Rules:

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

Strategy:

innermost

As we are in the innermost case, we can delete all 2 non-usable-rules.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

           →DP Problem 14

             ↳A-Transformation

Dependency Pair:

APP(sort, app(app(cons, n), x)) -> APP(sort, app(app(app(replace, app(min, app(app(cons, n), x))), n), x))

Rules:

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

Strategy:

innermost

We have an applicative DP problem with proper arity. Thus we can use the A-Transformation to obtain one new DP problem which consists of the A-transformed TRSs.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

           →DP Problem 14

             ↳ATrans

...

               →DP Problem 15

                 ↳Negative Polynomial Order

Dependency Pair:

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

Rules:

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

Strategy:

innermost

The following Dependency Pair can be strictly oriented using the given order.

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

Moreover, the following usable rules (regarding the implicit AFS) are oriented.

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

Used ordering:
Polynomial Order with Interpretation:

POL( SORT(x₁) ) = x₁

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

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

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

POL( min(x₁) ) = 0

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

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

POL( if_replace(x₁, ..., x₄) ) = x₄

POL( true ) = 0

POL( false ) = 0

POL( 0 ) = 0

POL( s(x₁) ) = 0

POL( nil ) = 0

This results in one new DP problem.

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

           →DP Problem 14

             ↳ATrans

...

               →DP Problem 16

                 ↳Dependency Graph

Dependency Pair:

Rules:

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

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

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