Term Rewriting System R:
[X, Y, N, M, Z]
lt(0, s(X)) -> true
lt(s(X), 0) -> false
lt(s(X), s(Y)) -> lt(X, Y)
append(nil, Y) -> Y
append(add(N, X), Y) -> add(N, append(X, Y))
split(N, nil) -> pair(nil, nil)
split(N, add(M, Y)) -> f1(split(N, Y), N, M, Y)
f1(pair(X, Z), N, M, Y) -> f2(lt(N, M), N, M, Y, X, Z)
f2(true, N, M, Y, X, Z) -> pair(X, add(M, Z))
f2(false, N, M, Y, X, Z) -> pair(add(M, X), Z)
qsort(nil) -> nil
qsort(add(N, X)) -> f3(split(N, X), N, X)
f3(pair(Y, Z), N, X) -> append(qsort(Y), add(X, qsort(Z)))

Termination of R to be shown. 



   R
     ↳Overlay and local confluence Check



The TRS is overlay and locally confluent (all critical pairs are trivially joinable).Hence, we can switch to innermost. 


   R
     ↳OC
       →TRS2
         ↳Dependency Pair Analysis



R contains the following Dependency Pairs:

LT(s(X), s(Y)) -> LT(X, Y)
APPEND(add(N, X), Y) -> APPEND(X, Y)
SPLIT(N, add(M, Y)) -> F1(split(N, Y), N, M, Y)
SPLIT(N, add(M, Y)) -> SPLIT(N, Y)
F1(pair(X, Z), N, M, Y) -> F2(lt(N, M), N, M, Y, X, Z)
F1(pair(X, Z), N, M, Y) -> LT(N, M)
QSORT(add(N, X)) -> F3(split(N, X), N, X)
QSORT(add(N, X)) -> SPLIT(N, X)
F3(pair(Y, Z), N, X) -> APPEND(qsort(Y), add(X, qsort(Z)))
F3(pair(Y, Z), N, X) -> QSORT(Y)
F3(pair(Y, Z), N, X) -> QSORT(Z)

Furthermore, R contains four SCCs. 


   R
     ↳OC
       →TRS2
         ↳DPs
           →DP Problem 1
             ↳Usable Rules (Innermost)
           →DP Problem 2
             ↳UsableRules
           →DP Problem 3
             ↳UsableRules
           →DP Problem 4
             ↳UsableRules


Dependency Pair:

LT(s(X), s(Y)) -> LT(X, Y)


Rules:


lt(0, s(X)) -> true
lt(s(X), 0) -> false
lt(s(X), s(Y)) -> lt(X, Y)
append(nil, Y) -> Y
append(add(N, X), Y) -> add(N, append(X, Y))
split(N, nil) -> pair(nil, nil)
split(N, add(M, Y)) -> f1(split(N, Y), N, M, Y)
f1(pair(X, Z), N, M, Y) -> f2(lt(N, M), N, M, Y, X, Z)
f2(true, N, M, Y, X, Z) -> pair(X, add(M, Z))
f2(false, N, M, Y, X, Z) -> pair(add(M, X), Z)
qsort(nil) -> nil
qsort(add(N, X)) -> f3(split(N, X), N, X)
f3(pair(Y, Z), N, X) -> append(qsort(Y), add(X, qsort(Z)))


Strategy:

innermost




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


   R
     ↳OC
       →TRS2
         ↳DPs
           →DP Problem 1
             ↳UsableRules
             ...
               →DP Problem 5
                 ↳Size-Change Principle
           →DP Problem 2
             ↳UsableRules
           →DP Problem 3
             ↳UsableRules
           →DP Problem 4
             ↳UsableRules


Dependency Pair:

LT(s(X), s(Y)) -> LT(X, Y)


Rule:

none


Strategy:

innermost




We number the DPs as follows:
  1. LT(s(X), s(Y)) -> LT(X, Y)
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

DP: empty set
Oriented Rules: none

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

with Argument Filtering System:
s(x1) -> s(x1)

We obtain no new DP problems. 


   R
     ↳OC
       →TRS2
         ↳DPs
           →DP Problem 1
             ↳UsableRules
           →DP Problem 2
             ↳Usable Rules (Innermost)
           →DP Problem 3
             ↳UsableRules
           →DP Problem 4
             ↳UsableRules


Dependency Pair:

APPEND(add(N, X), Y) -> APPEND(X, Y)


Rules:


lt(0, s(X)) -> true
lt(s(X), 0) -> false
lt(s(X), s(Y)) -> lt(X, Y)
append(nil, Y) -> Y
append(add(N, X), Y) -> add(N, append(X, Y))
split(N, nil) -> pair(nil, nil)
split(N, add(M, Y)) -> f1(split(N, Y), N, M, Y)
f1(pair(X, Z), N, M, Y) -> f2(lt(N, M), N, M, Y, X, Z)
f2(true, N, M, Y, X, Z) -> pair(X, add(M, Z))
f2(false, N, M, Y, X, Z) -> pair(add(M, X), Z)
qsort(nil) -> nil
qsort(add(N, X)) -> f3(split(N, X), N, X)
f3(pair(Y, Z), N, X) -> append(qsort(Y), add(X, qsort(Z)))


Strategy:

innermost




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


   R
     ↳OC
       →TRS2
         ↳DPs
           →DP Problem 1
             ↳UsableRules
           →DP Problem 2
             ↳UsableRules
             ...
               →DP Problem 6
                 ↳Size-Change Principle
           →DP Problem 3
             ↳UsableRules
           →DP Problem 4
             ↳UsableRules


Dependency Pair:

APPEND(add(N, X), Y) -> APPEND(X, Y)


Rule:

none


Strategy:

innermost




We number the DPs as follows:
  1. APPEND(add(N, X), Y) -> APPEND(X, Y)
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

DP: empty set
Oriented Rules: none

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

with Argument Filtering System:
add(x1, x2) -> add(x1, x2)

We obtain no new DP problems. 


   R
     ↳OC
       →TRS2
         ↳DPs
           →DP Problem 1
             ↳UsableRules
           →DP Problem 2
             ↳UsableRules
           →DP Problem 3
             ↳Usable Rules (Innermost)
           →DP Problem 4
             ↳UsableRules


Dependency Pair:

SPLIT(N, add(M, Y)) -> SPLIT(N, Y)


Rules:


lt(0, s(X)) -> true
lt(s(X), 0) -> false
lt(s(X), s(Y)) -> lt(X, Y)
append(nil, Y) -> Y
append(add(N, X), Y) -> add(N, append(X, Y))
split(N, nil) -> pair(nil, nil)
split(N, add(M, Y)) -> f1(split(N, Y), N, M, Y)
f1(pair(X, Z), N, M, Y) -> f2(lt(N, M), N, M, Y, X, Z)
f2(true, N, M, Y, X, Z) -> pair(X, add(M, Z))
f2(false, N, M, Y, X, Z) -> pair(add(M, X), Z)
qsort(nil) -> nil
qsort(add(N, X)) -> f3(split(N, X), N, X)
f3(pair(Y, Z), N, X) -> append(qsort(Y), add(X, qsort(Z)))


Strategy:

innermost




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


   R
     ↳OC
       →TRS2
         ↳DPs
           →DP Problem 1
             ↳UsableRules
           →DP Problem 2
             ↳UsableRules
           →DP Problem 3
             ↳UsableRules
             ...
               →DP Problem 7
                 ↳Size-Change Principle
           →DP Problem 4
             ↳UsableRules


Dependency Pair:

SPLIT(N, add(M, Y)) -> SPLIT(N, Y)


Rule:

none


Strategy:

innermost




We number the DPs as follows:
  1. SPLIT(N, add(M, Y)) -> SPLIT(N, Y)
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

DP: empty set
Oriented Rules: none

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

with Argument Filtering System:
add(x1, x2) -> add(x1, x2)

We obtain no new DP problems. 


   R
     ↳OC
       →TRS2
         ↳DPs
           →DP Problem 1
             ↳UsableRules
           →DP Problem 2
             ↳UsableRules
           →DP Problem 3
             ↳UsableRules
           →DP Problem 4
             ↳Usable Rules (Innermost)


Dependency Pairs:

F3(pair(Y, Z), N, X) -> QSORT(Z)
F3(pair(Y, Z), N, X) -> QSORT(Y)
QSORT(add(N, X)) -> F3(split(N, X), N, X)


Rules:


lt(0, s(X)) -> true
lt(s(X), 0) -> false
lt(s(X), s(Y)) -> lt(X, Y)
append(nil, Y) -> Y
append(add(N, X), Y) -> add(N, append(X, Y))
split(N, nil) -> pair(nil, nil)
split(N, add(M, Y)) -> f1(split(N, Y), N, M, Y)
f1(pair(X, Z), N, M, Y) -> f2(lt(N, M), N, M, Y, X, Z)
f2(true, N, M, Y, X, Z) -> pair(X, add(M, Z))
f2(false, N, M, Y, X, Z) -> pair(add(M, X), Z)
qsort(nil) -> nil
qsort(add(N, X)) -> f3(split(N, X), N, X)
f3(pair(Y, Z), N, X) -> append(qsort(Y), add(X, qsort(Z)))


Strategy:

innermost




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


   R
     ↳OC
       →TRS2
         ↳DPs
           →DP Problem 1
             ↳UsableRules
           →DP Problem 2
             ↳UsableRules
           →DP Problem 3
             ↳UsableRules
           →DP Problem 4
             ↳UsableRules
             ...
               →DP Problem 8
                 ↳Negative Polynomial Order


Dependency Pairs:

F3(pair(Y, Z), N, X) -> QSORT(Z)
F3(pair(Y, Z), N, X) -> QSORT(Y)
QSORT(add(N, X)) -> F3(split(N, X), N, X)


Rules:


f2(false, N, M, Y, X, Z) -> pair(add(M, X), Z)
f2(true, N, M, Y, X, Z) -> pair(X, add(M, Z))
lt(0, s(X)) -> true
lt(s(X), 0) -> false
lt(s(X), s(Y)) -> lt(X, Y)
split(N, nil) -> pair(nil, nil)
split(N, add(M, Y)) -> f1(split(N, Y), N, M, Y)
f1(pair(X, Z), N, M, Y) -> f2(lt(N, M), N, M, Y, X, Z)


Strategy:

innermost




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

F3(pair(Y, Z), N, X) -> QSORT(Z)
F3(pair(Y, Z), N, X) -> QSORT(Y)


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

f2(false, N, M, Y, X, Z) -> pair(add(M, X), Z)
f2(true, N, M, Y, X, Z) -> pair(X, add(M, Z))
lt(0, s(X)) -> true
lt(s(X), 0) -> false
lt(s(X), s(Y)) -> lt(X, Y)
split(N, nil) -> pair(nil, nil)
split(N, add(M, Y)) -> f1(split(N, Y), N, M, Y)
f1(pair(X, Z), N, M, Y) -> f2(lt(N, M), N, M, Y, X, Z)


Used ordering:
Polynomial Order with Interpretation:

POL( F3(x1, ..., x3) ) = x1

POL( pair(x1, x2) ) = x1 + x2 + 1

POL( QSORT(x1) ) = x1

POL( add(x1, x2) ) = x2 + 1

POL( split(x1, x2) ) = x2 + 1

POL( f2(x1, ..., x6) ) = x1 + x5 + x6 + 1

POL( false ) = 1

POL( true ) = 1

POL( lt(x1, x2) ) = 1

POL( nil ) = 0

POL( f1(x1, ..., x4) ) = x1 + 1


This results in one new DP problem. 


   R
     ↳OC
       →TRS2
         ↳DPs
           →DP Problem 1
             ↳UsableRules
           →DP Problem 2
             ↳UsableRules
           →DP Problem 3
             ↳UsableRules
           →DP Problem 4
             ↳UsableRules
             ...
               →DP Problem 9
                 ↳Dependency Graph


Dependency Pair:

QSORT(add(N, X)) -> F3(split(N, X), N, X)


Rules:


f2(false, N, M, Y, X, Z) -> pair(add(M, X), Z)
f2(true, N, M, Y, X, Z) -> pair(X, add(M, Z))
lt(0, s(X)) -> true
lt(s(X), 0) -> false
lt(s(X), s(Y)) -> lt(X, Y)
split(N, nil) -> pair(nil, nil)
split(N, add(M, Y)) -> f1(split(N, Y), N, M, Y)
f1(pair(X, Z), N, M, Y) -> f2(lt(N, M), N, M, Y, X, Z)


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.

Termination of R successfully shown.
Duration:
0:01 minutes