Termination Proof using AProVE

Term Rewriting System R:
[x, y, z]
bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Innermost Termination of R to be shown.

     ↳Dependency Pair Analysis

R contains the following Dependency Pairs:

BSORT(.(x, y)) -> LAST(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
BSORT(.(x, y)) -> BUBBLE(.(x, y))
BSORT(.(x, y)) -> BSORT(butlast(bubble(.(x, y))))
BSORT(.(x, y)) -> BUTLAST(bubble(.(x, y)))
BUBBLE(.(x, .(y, z))) -> BUBBLE(.(x, z))
BUBBLE(.(x, .(y, z))) -> BUBBLE(.(y, z))
LAST(.(x, .(y, z))) -> LAST(.(y, z))
BUTLAST(.(x, .(y, z))) -> BUTLAST(.(y, z))

Furthermore, R contains four SCCs.

     ↳DPs

       →DP Problem 1

         ↳Forward Instantiation Transformation

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

Dependency Pair:

LAST(.(x, .(y, z))) -> LAST(.(y, z))

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

LAST(.(x, .(y, z))) -> LAST(.(y, z))

one new Dependency Pair is created:

LAST(.(x, .(y0, .(y'', z'')))) -> LAST(.(y0, .(y'', z'')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

           →DP Problem 5

             ↳Forward Instantiation Transformation

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

Dependency Pair:

LAST(.(x, .(y0, .(y'', z'')))) -> LAST(.(y0, .(y'', z'')))

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

LAST(.(x, .(y0, .(y'', z'')))) -> LAST(.(y0, .(y'', z'')))

one new Dependency Pair is created:

LAST(.(x, .(y0'', .(y''0, .(y'''', z''''))))) -> LAST(.(y0'', .(y''0, .(y'''', z''''))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

           →DP Problem 5

             ↳FwdInst

...

               →DP Problem 6

                 ↳Argument Filtering and Ordering

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

Dependency Pair:

LAST(.(x, .(y0'', .(y''0, .(y'''', z''''))))) -> LAST(.(y0'', .(y''0, .(y'''', z''''))))

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

The following dependency pair can be strictly oriented:

LAST(.(x, .(y0'', .(y''0, .(y'''', z''''))))) -> LAST(.(y0'', .(y''0, .(y'''', z''''))))

There are no usable rules for innermost that need to be oriented.
Used ordering: Polynomial ordering with Polynomial interpretation:

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

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

resulting in one new DP problem.
Used Argument Filtering System:

LAST(x₁) -> LAST(x₁)
.(x₁, x₂) -> .(x₁, x₂)

     ↳DPs

       →DP Problem 1

         ↳FwdInst

           →DP Problem 5

             ↳FwdInst

...

               →DP Problem 7

                 ↳Dependency Graph

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

Dependency Pair:

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳Forward Instantiation Transformation

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

Dependency Pairs:

BUBBLE(.(x, .(y, z))) -> BUBBLE(.(y, z))
BUBBLE(.(x, .(y, z))) -> BUBBLE(.(x, z))

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUBBLE(.(x, .(y, z))) -> BUBBLE(.(x, z))

one new Dependency Pair is created:

BUBBLE(.(x'', .(y, .(y'', z'')))) -> BUBBLE(.(x'', .(y'', z'')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

           →DP Problem 8

             ↳Forward Instantiation Transformation

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

Dependency Pairs:

BUBBLE(.(x'', .(y, .(y'', z'')))) -> BUBBLE(.(x'', .(y'', z'')))
BUBBLE(.(x, .(y, z))) -> BUBBLE(.(y, z))

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUBBLE(.(x, .(y, z))) -> BUBBLE(.(y, z))

two new Dependency Pairs are created:

BUBBLE(.(x, .(y0, .(y'', z'')))) -> BUBBLE(.(y0, .(y'', z'')))
BUBBLE(.(x, .(y0, .(y'', .(y'''', z''''))))) -> BUBBLE(.(y0, .(y'', .(y'''', z''''))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

           →DP Problem 8

             ↳FwdInst

...

               →DP Problem 9

                 ↳Forward Instantiation Transformation

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

Dependency Pairs:

BUBBLE(.(x, .(y0, .(y'', .(y'''', z''''))))) -> BUBBLE(.(y0, .(y'', .(y'''', z''''))))
BUBBLE(.(x, .(y0, .(y'', z'')))) -> BUBBLE(.(y0, .(y'', z'')))
BUBBLE(.(x'', .(y, .(y'', z'')))) -> BUBBLE(.(x'', .(y'', z'')))

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUBBLE(.(x'', .(y, .(y'', z'')))) -> BUBBLE(.(x'', .(y'', z'')))

three new Dependency Pairs are created:

BUBBLE(.(x'''', .(y, .(y''0, .(y'''', z''''))))) -> BUBBLE(.(x'''', .(y''0, .(y'''', z''''))))
BUBBLE(.(x''', .(y, .(y''0, .(y'''', z''''))))) -> BUBBLE(.(x''', .(y''0, .(y'''', z''''))))
BUBBLE(.(x''', .(y, .(y''0, .(y'''', .(y'''''', z'''''')))))) -> BUBBLE(.(x''', .(y''0, .(y'''', .(y'''''', z'''''')))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

           →DP Problem 8

             ↳FwdInst

...

               →DP Problem 10

                 ↳Forward Instantiation Transformation

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

Dependency Pairs:

BUBBLE(.(x''', .(y, .(y''0, .(y'''', .(y'''''', z'''''')))))) -> BUBBLE(.(x''', .(y''0, .(y'''', .(y'''''', z'''''')))))
BUBBLE(.(x''', .(y, .(y''0, .(y'''', z''''))))) -> BUBBLE(.(x''', .(y''0, .(y'''', z''''))))
BUBBLE(.(x'''', .(y, .(y''0, .(y'''', z''''))))) -> BUBBLE(.(x'''', .(y''0, .(y'''', z''''))))
BUBBLE(.(x, .(y0, .(y'', z'')))) -> BUBBLE(.(y0, .(y'', z'')))
BUBBLE(.(x, .(y0, .(y'', .(y'''', z''''))))) -> BUBBLE(.(y0, .(y'', .(y'''', z''''))))

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUBBLE(.(x, .(y0, .(y'', z'')))) -> BUBBLE(.(y0, .(y'', z'')))

four new Dependency Pairs are created:

BUBBLE(.(x, .(y0'', .(y''0, .(y'''', z''''))))) -> BUBBLE(.(y0'', .(y''0, .(y'''', z''''))))
BUBBLE(.(x, .(y0'', .(y''0, .(y'''', .(y'''''', z'''''')))))) -> BUBBLE(.(y0'', .(y''0, .(y'''', .(y'''''', z'''''')))))
BUBBLE(.(x, .(y0', .(y''', .(y''0'', .(y'''''', z'''''')))))) -> BUBBLE(.(y0', .(y''', .(y''0'', .(y'''''', z'''''')))))
BUBBLE(.(x, .(y0', .(y''', .(y''0'', .(y'''''', .(y'''''''', z''''''''))))))) -> BUBBLE(.(y0', .(y''', .(y''0'', .(y'''''', .(y'''''''', z''''''''))))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

           →DP Problem 8

             ↳FwdInst

...

               →DP Problem 11

                 ↳Forward Instantiation Transformation

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

Dependency Pairs:

BUBBLE(.(x, .(y0', .(y''', .(y''0'', .(y'''''', .(y'''''''', z''''''''))))))) -> BUBBLE(.(y0', .(y''', .(y''0'', .(y'''''', .(y'''''''', z''''''''))))))
BUBBLE(.(x, .(y0', .(y''', .(y''0'', .(y'''''', z'''''')))))) -> BUBBLE(.(y0', .(y''', .(y''0'', .(y'''''', z'''''')))))
BUBBLE(.(x, .(y0'', .(y''0, .(y'''', .(y'''''', z'''''')))))) -> BUBBLE(.(y0'', .(y''0, .(y'''', .(y'''''', z'''''')))))
BUBBLE(.(x, .(y0'', .(y''0, .(y'''', z''''))))) -> BUBBLE(.(y0'', .(y''0, .(y'''', z''''))))
BUBBLE(.(x''', .(y, .(y''0, .(y'''', z''''))))) -> BUBBLE(.(x''', .(y''0, .(y'''', z''''))))
BUBBLE(.(x'''', .(y, .(y''0, .(y'''', z''''))))) -> BUBBLE(.(x'''', .(y''0, .(y'''', z''''))))
BUBBLE(.(x, .(y0, .(y'', .(y'''', z''''))))) -> BUBBLE(.(y0, .(y'', .(y'''', z''''))))
BUBBLE(.(x''', .(y, .(y''0, .(y'''', .(y'''''', z'''''')))))) -> BUBBLE(.(x''', .(y''0, .(y'''', .(y'''''', z'''''')))))

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUBBLE(.(x, .(y0, .(y'', .(y'''', z''''))))) -> BUBBLE(.(y0, .(y'', .(y'''', z''''))))

five new Dependency Pairs are created:

BUBBLE(.(x, .(y0'', .(y''0, .(y''''0, .(y'''''', z'''''')))))) -> BUBBLE(.(y0'', .(y''0, .(y''''0, .(y'''''', z'''''')))))
BUBBLE(.(x, .(y0', .(y''', .(y''''0, .(y'''''', z'''''')))))) -> BUBBLE(.(y0', .(y''', .(y''''0, .(y'''''', z'''''')))))
BUBBLE(.(x, .(y0', .(y''', .(y''''0, .(y'''''', .(y'''''''', z''''''''))))))) -> BUBBLE(.(y0', .(y''', .(y''''0, .(y'''''', .(y'''''''', z''''''''))))))
BUBBLE(.(x, .(y0', .(y''', .(y'''''', .(y''0'''', .(y'''''''', z''''''''))))))) -> BUBBLE(.(y0', .(y''', .(y'''''', .(y''0'''', .(y'''''''', z''''''''))))))
BUBBLE(.(x, .(y0', .(y''', .(y'''''', .(y''0'''', .(y'''''''', .(y'''''''''', z'''''''''')))))))) -> BUBBLE(.(y0', .(y''', .(y'''''', .(y''0'''', .(y'''''''', .(y'''''''''', z'''''''''')))))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

           →DP Problem 8

             ↳FwdInst

...

               →DP Problem 12

                 ↳Argument Filtering and Ordering

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

Dependency Pairs:

BUBBLE(.(x, .(y0', .(y''', .(y'''''', .(y''0'''', .(y'''''''', .(y'''''''''', z'''''''''')))))))) -> BUBBLE(.(y0', .(y''', .(y'''''', .(y''0'''', .(y'''''''', .(y'''''''''', z'''''''''')))))))
BUBBLE(.(x, .(y0', .(y''', .(y'''''', .(y''0'''', .(y'''''''', z''''''''))))))) -> BUBBLE(.(y0', .(y''', .(y'''''', .(y''0'''', .(y'''''''', z''''''''))))))
BUBBLE(.(x, .(y0', .(y''', .(y''''0, .(y'''''', .(y'''''''', z''''''''))))))) -> BUBBLE(.(y0', .(y''', .(y''''0, .(y'''''', .(y'''''''', z''''''''))))))
BUBBLE(.(x, .(y0', .(y''', .(y''''0, .(y'''''', z'''''')))))) -> BUBBLE(.(y0', .(y''', .(y''''0, .(y'''''', z'''''')))))
BUBBLE(.(x, .(y0'', .(y''0, .(y''''0, .(y'''''', z'''''')))))) -> BUBBLE(.(y0'', .(y''0, .(y''''0, .(y'''''', z'''''')))))
BUBBLE(.(x, .(y0', .(y''', .(y''0'', .(y'''''', z'''''')))))) -> BUBBLE(.(y0', .(y''', .(y''0'', .(y'''''', z'''''')))))
BUBBLE(.(x, .(y0'', .(y''0, .(y'''', .(y'''''', z'''''')))))) -> BUBBLE(.(y0'', .(y''0, .(y'''', .(y'''''', z'''''')))))
BUBBLE(.(x, .(y0'', .(y''0, .(y'''', z''''))))) -> BUBBLE(.(y0'', .(y''0, .(y'''', z''''))))
BUBBLE(.(x''', .(y, .(y''0, .(y'''', .(y'''''', z'''''')))))) -> BUBBLE(.(x''', .(y''0, .(y'''', .(y'''''', z'''''')))))
BUBBLE(.(x''', .(y, .(y''0, .(y'''', z''''))))) -> BUBBLE(.(x''', .(y''0, .(y'''', z''''))))
BUBBLE(.(x'''', .(y, .(y''0, .(y'''', z''''))))) -> BUBBLE(.(x'''', .(y''0, .(y'''', z''''))))
BUBBLE(.(x, .(y0', .(y''', .(y''0'', .(y'''''', .(y'''''''', z''''''''))))))) -> BUBBLE(.(y0', .(y''', .(y''0'', .(y'''''', .(y'''''''', z''''''''))))))

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

The following dependency pairs can be strictly oriented:

BUBBLE(.(x, .(y0', .(y''', .(y'''''', .(y''0'''', .(y'''''''', .(y'''''''''', z'''''''''')))))))) -> BUBBLE(.(y0', .(y''', .(y'''''', .(y''0'''', .(y'''''''', .(y'''''''''', z'''''''''')))))))
BUBBLE(.(x, .(y0', .(y''', .(y'''''', .(y''0'''', .(y'''''''', z''''''''))))))) -> BUBBLE(.(y0', .(y''', .(y'''''', .(y''0'''', .(y'''''''', z''''''''))))))
BUBBLE(.(x, .(y0', .(y''', .(y''''0, .(y'''''', .(y'''''''', z''''''''))))))) -> BUBBLE(.(y0', .(y''', .(y''''0, .(y'''''', .(y'''''''', z''''''''))))))
BUBBLE(.(x, .(y0', .(y''', .(y''''0, .(y'''''', z'''''')))))) -> BUBBLE(.(y0', .(y''', .(y''''0, .(y'''''', z'''''')))))
BUBBLE(.(x, .(y0'', .(y''0, .(y''''0, .(y'''''', z'''''')))))) -> BUBBLE(.(y0'', .(y''0, .(y''''0, .(y'''''', z'''''')))))
BUBBLE(.(x, .(y0', .(y''', .(y''0'', .(y'''''', z'''''')))))) -> BUBBLE(.(y0', .(y''', .(y''0'', .(y'''''', z'''''')))))
BUBBLE(.(x, .(y0'', .(y''0, .(y'''', .(y'''''', z'''''')))))) -> BUBBLE(.(y0'', .(y''0, .(y'''', .(y'''''', z'''''')))))
BUBBLE(.(x, .(y0'', .(y''0, .(y'''', z''''))))) -> BUBBLE(.(y0'', .(y''0, .(y'''', z''''))))
BUBBLE(.(x''', .(y, .(y''0, .(y'''', .(y'''''', z'''''')))))) -> BUBBLE(.(x''', .(y''0, .(y'''', .(y'''''', z'''''')))))
BUBBLE(.(x''', .(y, .(y''0, .(y'''', z''''))))) -> BUBBLE(.(x''', .(y''0, .(y'''', z''''))))
BUBBLE(.(x'''', .(y, .(y''0, .(y'''', z''''))))) -> BUBBLE(.(x'''', .(y''0, .(y'''', z''''))))
BUBBLE(.(x, .(y0', .(y''', .(y''0'', .(y'''''', .(y'''''''', z''''''''))))))) -> BUBBLE(.(y0', .(y''', .(y''0'', .(y'''''', .(y'''''''', z''''''''))))))

There are no usable rules for innermost that need to be oriented.
Used ordering: Polynomial ordering with Polynomial interpretation:

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

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

resulting in one new DP problem.
Used Argument Filtering System:

BUBBLE(x₁) -> BUBBLE(x₁)
.(x₁, x₂) -> .(x₁, x₂)

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

           →DP Problem 8

             ↳FwdInst

...

               →DP Problem 13

                 ↳Dependency Graph

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

Dependency Pair:

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Forward Instantiation Transformation

       →DP Problem 4

         ↳Nar

Dependency Pair:

BUTLAST(.(x, .(y, z))) -> BUTLAST(.(y, z))

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUTLAST(.(x, .(y, z))) -> BUTLAST(.(y, z))

one new Dependency Pair is created:

BUTLAST(.(x, .(y0, .(y'', z'')))) -> BUTLAST(.(y0, .(y'', z'')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

           →DP Problem 14

             ↳Forward Instantiation Transformation

       →DP Problem 4

         ↳Nar

Dependency Pair:

BUTLAST(.(x, .(y0, .(y'', z'')))) -> BUTLAST(.(y0, .(y'', z'')))

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

BUTLAST(.(x, .(y0, .(y'', z'')))) -> BUTLAST(.(y0, .(y'', z'')))

one new Dependency Pair is created:

BUTLAST(.(x, .(y0'', .(y''0, .(y'''', z''''))))) -> BUTLAST(.(y0'', .(y''0, .(y'''', z''''))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

           →DP Problem 14

             ↳FwdInst

...

               →DP Problem 15

                 ↳Argument Filtering and Ordering

       →DP Problem 4

         ↳Nar

Dependency Pair:

BUTLAST(.(x, .(y0'', .(y''0, .(y'''', z''''))))) -> BUTLAST(.(y0'', .(y''0, .(y'''', z''''))))

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

The following dependency pair can be strictly oriented:

BUTLAST(.(x, .(y0'', .(y''0, .(y'''', z''''))))) -> BUTLAST(.(y0'', .(y''0, .(y'''', z''''))))

There are no usable rules for innermost that need to be oriented.
Used ordering: Polynomial ordering with Polynomial interpretation:

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

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

resulting in one new DP problem.
Used Argument Filtering System:

BUTLAST(x₁) -> BUTLAST(x₁)
.(x₁, x₂) -> .(x₁, x₂)

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

           →DP Problem 14

             ↳FwdInst

...

               →DP Problem 16

                 ↳Dependency Graph

       →DP Problem 4

         ↳Nar

Dependency Pair:

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Narrowing Transformation

Dependency Pair:

BSORT(.(x, y)) -> BSORT(butlast(bubble(.(x, y))))

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

BSORT(.(x, y)) -> BSORT(butlast(bubble(.(x, y))))

two new Dependency Pairs are created:

BSORT(.(x'', nil)) -> BSORT(butlast(.(x'', nil)))
BSORT(.(x'', .(y'', z'))) -> BSORT(butlast(if(<=(x'', y''), .(y'', bubble(.(x'', z'))), .(x'', bubble(.(y'', z'))))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 17

             ↳Rewriting Transformation

Dependency Pairs:

BSORT(.(x'', .(y'', z'))) -> BSORT(butlast(if(<=(x'', y''), .(y'', bubble(.(x'', z'))), .(x'', bubble(.(y'', z'))))))
BSORT(.(x'', nil)) -> BSORT(butlast(.(x'', nil)))

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

On this DP problem, a Rewriting SCC transformation can be performed.
As a result of transforming the rule

BSORT(.(x'', nil)) -> BSORT(butlast(.(x'', nil)))

one new Dependency Pair is created:

BSORT(.(x'', nil)) -> BSORT(nil)

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 17

             ↳Rw

...

               →DP Problem 18

                 ↳Narrowing Transformation

Dependency Pair:

BSORT(.(x'', .(y'', z'))) -> BSORT(butlast(if(<=(x'', y''), .(y'', bubble(.(x'', z'))), .(x'', bubble(.(y'', z'))))))

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

BSORT(.(x'', .(y'', z'))) -> BSORT(butlast(if(<=(x'', y''), .(y'', bubble(.(x'', z'))), .(x'', bubble(.(y'', z'))))))

four new Dependency Pairs are created:

BSORT(.(x''', .(y'', nil))) -> BSORT(butlast(if(<=(x''', y''), .(y'', .(x''', nil)), .(x''', bubble(.(y'', nil))))))
BSORT(.(x''', .(y'', .(y', z'')))) -> BSORT(butlast(if(<=(x''', y''), .(y'', if(<=(x''', y'), .(y', bubble(.(x''', z''))), .(x''', bubble(.(y', z''))))), .(x''', bubble(.(y'', .(y', z'')))))))
BSORT(.(x'', .(y''', nil))) -> BSORT(butlast(if(<=(x'', y'''), .(y''', bubble(.(x'', nil))), .(x'', .(y''', nil)))))
BSORT(.(x'', .(y''', .(y', z'')))) -> BSORT(butlast(if(<=(x'', y'''), .(y''', bubble(.(x'', .(y', z'')))), .(x'', if(<=(y''', y'), .(y', bubble(.(y''', z''))), .(y''', bubble(.(y', z''))))))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 17

             ↳Rw

...

               →DP Problem 19

                 ↳Rewriting Transformation

Dependency Pairs:

BSORT(.(x'', .(y''', .(y', z'')))) -> BSORT(butlast(if(<=(x'', y'''), .(y''', bubble(.(x'', .(y', z'')))), .(x'', if(<=(y''', y'), .(y', bubble(.(y''', z''))), .(y''', bubble(.(y', z''))))))))
BSORT(.(x'', .(y''', nil))) -> BSORT(butlast(if(<=(x'', y'''), .(y''', bubble(.(x'', nil))), .(x'', .(y''', nil)))))
BSORT(.(x''', .(y'', .(y', z'')))) -> BSORT(butlast(if(<=(x''', y''), .(y'', if(<=(x''', y'), .(y', bubble(.(x''', z''))), .(x''', bubble(.(y', z''))))), .(x''', bubble(.(y'', .(y', z'')))))))
BSORT(.(x''', .(y'', nil))) -> BSORT(butlast(if(<=(x''', y''), .(y'', .(x''', nil)), .(x''', bubble(.(y'', nil))))))

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

On this DP problem, a Rewriting SCC transformation can be performed.
As a result of transforming the rule

BSORT(.(x''', .(y'', nil))) -> BSORT(butlast(if(<=(x''', y''), .(y'', .(x''', nil)), .(x''', bubble(.(y'', nil))))))

one new Dependency Pair is created:

BSORT(.(x''', .(y'', nil))) -> BSORT(butlast(if(<=(x''', y''), .(y'', .(x''', nil)), .(x''', .(y'', nil)))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 17

             ↳Rw

...

               →DP Problem 20

                 ↳Rewriting Transformation

Dependency Pairs:

BSORT(.(x''', .(y'', nil))) -> BSORT(butlast(if(<=(x''', y''), .(y'', .(x''', nil)), .(x''', .(y'', nil)))))
BSORT(.(x'', .(y''', nil))) -> BSORT(butlast(if(<=(x'', y'''), .(y''', bubble(.(x'', nil))), .(x'', .(y''', nil)))))
BSORT(.(x''', .(y'', .(y', z'')))) -> BSORT(butlast(if(<=(x''', y''), .(y'', if(<=(x''', y'), .(y', bubble(.(x''', z''))), .(x''', bubble(.(y', z''))))), .(x''', bubble(.(y'', .(y', z'')))))))
BSORT(.(x'', .(y''', .(y', z'')))) -> BSORT(butlast(if(<=(x'', y'''), .(y''', bubble(.(x'', .(y', z'')))), .(x'', if(<=(y''', y'), .(y', bubble(.(y''', z''))), .(y''', bubble(.(y', z''))))))))

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

On this DP problem, a Rewriting SCC transformation can be performed.
As a result of transforming the rule

BSORT(.(x''', .(y'', .(y', z'')))) -> BSORT(butlast(if(<=(x''', y''), .(y'', if(<=(x''', y'), .(y', bubble(.(x''', z''))), .(x''', bubble(.(y', z''))))), .(x''', bubble(.(y'', .(y', z'')))))))

one new Dependency Pair is created:

BSORT(.(x''', .(y'', .(y', z'')))) -> BSORT(butlast(if(<=(x''', y''), .(y'', if(<=(x''', y'), .(y', bubble(.(x''', z''))), .(x''', bubble(.(y', z''))))), .(x''', if(<=(y'', y'), .(y', bubble(.(y'', z''))), .(y'', bubble(.(y', z''))))))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 17

             ↳Rw

...

               →DP Problem 21

                 ↳Rewriting Transformation

Dependency Pairs:

BSORT(.(x''', .(y'', .(y', z'')))) -> BSORT(butlast(if(<=(x''', y''), .(y'', if(<=(x''', y'), .(y', bubble(.(x''', z''))), .(x''', bubble(.(y', z''))))), .(x''', if(<=(y'', y'), .(y', bubble(.(y'', z''))), .(y'', bubble(.(y', z''))))))))
BSORT(.(x'', .(y''', .(y', z'')))) -> BSORT(butlast(if(<=(x'', y'''), .(y''', bubble(.(x'', .(y', z'')))), .(x'', if(<=(y''', y'), .(y', bubble(.(y''', z''))), .(y''', bubble(.(y', z''))))))))
BSORT(.(x'', .(y''', nil))) -> BSORT(butlast(if(<=(x'', y'''), .(y''', bubble(.(x'', nil))), .(x'', .(y''', nil)))))
BSORT(.(x''', .(y'', nil))) -> BSORT(butlast(if(<=(x''', y''), .(y'', .(x''', nil)), .(x''', .(y'', nil)))))

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

On this DP problem, a Rewriting SCC transformation can be performed.
As a result of transforming the rule

BSORT(.(x'', .(y''', nil))) -> BSORT(butlast(if(<=(x'', y'''), .(y''', bubble(.(x'', nil))), .(x'', .(y''', nil)))))

one new Dependency Pair is created:

BSORT(.(x'', .(y''', nil))) -> BSORT(butlast(if(<=(x'', y'''), .(y''', .(x'', nil)), .(x'', .(y''', nil)))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 17

             ↳Rw

...

               →DP Problem 22

                 ↳Rewriting Transformation

Dependency Pairs:

BSORT(.(x'', .(y''', nil))) -> BSORT(butlast(if(<=(x'', y'''), .(y''', .(x'', nil)), .(x'', .(y''', nil)))))
BSORT(.(x''', .(y'', nil))) -> BSORT(butlast(if(<=(x''', y''), .(y'', .(x''', nil)), .(x''', .(y'', nil)))))
BSORT(.(x'', .(y''', .(y', z'')))) -> BSORT(butlast(if(<=(x'', y'''), .(y''', bubble(.(x'', .(y', z'')))), .(x'', if(<=(y''', y'), .(y', bubble(.(y''', z''))), .(y''', bubble(.(y', z''))))))))
BSORT(.(x''', .(y'', .(y', z'')))) -> BSORT(butlast(if(<=(x''', y''), .(y'', if(<=(x''', y'), .(y', bubble(.(x''', z''))), .(x''', bubble(.(y', z''))))), .(x''', if(<=(y'', y'), .(y', bubble(.(y'', z''))), .(y'', bubble(.(y', z''))))))))

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

On this DP problem, a Rewriting SCC transformation can be performed.
As a result of transforming the rule

BSORT(.(x'', .(y''', .(y', z'')))) -> BSORT(butlast(if(<=(x'', y'''), .(y''', bubble(.(x'', .(y', z'')))), .(x'', if(<=(y''', y'), .(y', bubble(.(y''', z''))), .(y''', bubble(.(y', z''))))))))

one new Dependency Pair is created:

BSORT(.(x'', .(y''', .(y', z'')))) -> BSORT(butlast(if(<=(x'', y'''), .(y''', if(<=(x'', y'), .(y', bubble(.(x'', z''))), .(x'', bubble(.(y', z''))))), .(x'', if(<=(y''', y'), .(y', bubble(.(y''', z''))), .(y''', bubble(.(y', z''))))))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 17

             ↳Rw

...

               →DP Problem 23

                 ↳Narrowing Transformation

Dependency Pairs:

BSORT(.(x'', .(y''', .(y', z'')))) -> BSORT(butlast(if(<=(x'', y'''), .(y''', if(<=(x'', y'), .(y', bubble(.(x'', z''))), .(x'', bubble(.(y', z''))))), .(x'', if(<=(y''', y'), .(y', bubble(.(y''', z''))), .(y''', bubble(.(y', z''))))))))
BSORT(.(x''', .(y'', .(y', z'')))) -> BSORT(butlast(if(<=(x''', y''), .(y'', if(<=(x''', y'), .(y', bubble(.(x''', z''))), .(x''', bubble(.(y', z''))))), .(x''', if(<=(y'', y'), .(y', bubble(.(y'', z''))), .(y'', bubble(.(y', z''))))))))
BSORT(.(x''', .(y'', nil))) -> BSORT(butlast(if(<=(x''', y''), .(y'', .(x''', nil)), .(x''', .(y'', nil)))))
BSORT(.(x'', .(y''', nil))) -> BSORT(butlast(if(<=(x'', y'''), .(y''', .(x'', nil)), .(x'', .(y''', nil)))))

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

BSORT(.(x''', .(y'', nil))) -> BSORT(butlast(if(<=(x''', y''), .(y'', .(x''', nil)), .(x''', .(y'', nil)))))

no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 17

             ↳Rw

...

               →DP Problem 24

                 ↳Narrowing Transformation

Dependency Pairs:

BSORT(.(x'', .(y''', nil))) -> BSORT(butlast(if(<=(x'', y'''), .(y''', .(x'', nil)), .(x'', .(y''', nil)))))
BSORT(.(x''', .(y'', .(y', z'')))) -> BSORT(butlast(if(<=(x''', y''), .(y'', if(<=(x''', y'), .(y', bubble(.(x''', z''))), .(x''', bubble(.(y', z''))))), .(x''', if(<=(y'', y'), .(y', bubble(.(y'', z''))), .(y'', bubble(.(y', z''))))))))
BSORT(.(x'', .(y''', .(y', z'')))) -> BSORT(butlast(if(<=(x'', y'''), .(y''', if(<=(x'', y'), .(y', bubble(.(x'', z''))), .(x'', bubble(.(y', z''))))), .(x'', if(<=(y''', y'), .(y', bubble(.(y''', z''))), .(y''', bubble(.(y', z''))))))))

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

BSORT(.(x'', .(y''', nil))) -> BSORT(butlast(if(<=(x'', y'''), .(y''', .(x'', nil)), .(x'', .(y''', nil)))))

no new Dependency Pairs are created.
The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 17

             ↳Rw

...

               →DP Problem 25

                 ↳Argument Filtering and Ordering

Dependency Pairs:

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

The following dependency pairs can be strictly oriented:

BSORT(.(x'', .(y''', .(y', z'')))) -> BSORT(butlast(if(<=(x'', y'''), .(y''', if(<=(x'', y'), .(y', bubble(.(x'', z''))), .(x'', bubble(.(y', z''))))), .(x'', if(<=(y''', y'), .(y', bubble(.(y''', z''))), .(y''', bubble(.(y', z''))))))))
BSORT(.(x''', .(y'', .(y', z'')))) -> BSORT(butlast(if(<=(x''', y''), .(y'', if(<=(x''', y'), .(y', bubble(.(x''', z''))), .(x''', bubble(.(y', z''))))), .(x''', if(<=(y'', y'), .(y', bubble(.(y'', z''))), .(y'', bubble(.(y', z''))))))))

The following usable rules for innermost can be oriented:

butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))

Used ordering: Polynomial ordering with Polynomial interpretation:

POL(butlast(x₁)) = x₁

POL(nil) = 0

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

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

POL(bubble(x₁)) = x₁

POL(<=(x₁, x₂)) = x₁ + x₂

resulting in one new DP problem.
Used Argument Filtering System:

BSORT(x₁) -> BSORT(x₁)
.(x₁, x₂) -> .(x₁, x₂)
butlast(x₁) -> butlast(x₁)
if(x₁, x₂, x₃) -> x₁
<=(x₁, x₂) -> <=(x₁, x₂)
bubble(x₁) -> bubble(x₁)

     ↳DPs

       →DP Problem 1

         ↳FwdInst

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Nar

           →DP Problem 17

             ↳Rw

...

               →DP Problem 26

                 ↳Dependency Graph

Dependency Pair:

Rules:

bsort(nil) -> nil
bsort(.(x, y)) -> last(.(bubble(.(x, y)), bsort(butlast(bubble(.(x, y))))))
bubble(nil) -> nil
bubble(.(x, nil)) -> .(x, nil)
bubble(.(x, .(y, z))) -> if(<=(x, y), .(y, bubble(.(x, z))), .(x, bubble(.(y, z))))
last(nil) -> 0
last(.(x, nil)) -> x
last(.(x, .(y, z))) -> last(.(y, z))
butlast(nil) -> nil
butlast(.(x, nil)) -> nil
butlast(.(x, .(y, z))) -> .(x, butlast(.(y, z)))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

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

POL(LAST(x₁))	= 1 + x₁
POL(.(x₁, x₂))	= 1 + x₁ + x₂

POL(BUBBLE(x₁))	= 1 + x₁
POL(.(x₁, x₂))	= 1 + x₁ + x₂

POL(BUTLAST(x₁))	= 1 + x₁
POL(.(x₁, x₂))	= 1 + x₁ + x₂

POL(butlast(x₁))	= x₁
POL(nil)	= 0
POL(.(x₁, x₂))	= 1 + x₁ + x₂
POL(BSORT(x₁))	= 1 + x₁
POL(bubble(x₁))	= x₁
POL(<=(x₁, x₂))	= x₁ + x₂