Termination Proof using AProVE

Term Rewriting System R:
[x, n, h, t, m, pid, st₁, in₂, st₂, in₃, st₃]
fstsplit(0, x) -> nil
fstsplit(s(n), nil) -> nil
fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t))
sndsplit(0, x) -> x
sndsplit(s(n), nil) -> nil
sndsplit(s(n), cons(h, t)) -> sndsplit(n, t)
empty(nil) -> true
empty(cons(h, t)) -> false
leq(0, m) -> true
leq(s(n), 0) -> false
leq(s(n), s(m)) -> leq(n, m)
length(nil) -> 0
length(cons(h, t)) -> s(length(t))
app(nil, x) -> x
app(cons(h, t), x) -> cons(h, app(t, x))
map_f(pid, nil) -> nil
map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t))
head(cons(h, t)) -> h
tail(cons(h, t)) -> t
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₁(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₁)))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₂(st₁, in₂, st₂, in₃, st₃, m, leq(m, length(st₂)))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₅(st₁, in₂, st₂, in₃, st₃, m, empty(map_f(two, head(in₂))))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₆(st₁, in₂, st₂, in₃, st₃, m, leq(m, length(st₃)))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₉(st₁, in₂, st₂, in₃, st₃, m, empty(map_f(three, head(in₃))))
if₁(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(sndsplit(m, st₁), cons(fstsplit(m, st₁), in₂), st₂, in₃, st₃, m)
if₂(st₁, in₂, st₂, in₃, st₃, m, true) -> if₃(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₂)))
if₂(st₁, in₂, st₂, in₃, st₃, m, false) -> if₄(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, app(map_f(two, head(in₂)), st₂))))
if₃(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, in₂, sndsplit(m, st₂), cons(fstsplit(m, st₂), in₃), st₃, m)
if₄(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, tail(in₂), sndsplit(m, app(map_f(two, head(in₂)), st₂)), cons(fstsplit(m, app(map_f(two, head(in₂)), st₂)), in₃), st₃, m)
if₅(st₁, in₂, st₂, in₃, st₃, m, true) -> ring(st₁, tail(in₂), st₂, in₃, st₃, m)
if₆(st₁, in₂, st₂, in₃, st₃, m, true) -> if₇(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₃)))
if₆(st₁, in₂, st₂, in₃, st₃, m, false) -> if₈(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, app(map_f(three, head(in₃)), st₃))))
if₇(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, in₂, st₂, in₃, sndsplit(m, st₃), m)
if₈(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, in₂, st₂, tail(in₃), sndsplit(m, app(map_f(three, head(in₃)), st₃)), m)
if₉(st₁, in₂, st₂, in₃, st₃, m, true) -> ring(st₁, in₂, st₂, tail(in₃), st₃, m)

Innermost Termination of R to be shown.

     ↳Dependency Pair Analysis

R contains the following Dependency Pairs:

FSTSPLIT(s(n), cons(h, t)) -> FSTSPLIT(n, t)
SNDSPLIT(s(n), cons(h, t)) -> SNDSPLIT(n, t)
LEQ(s(n), s(m)) -> LEQ(n, m)
LENGTH(cons(h, t)) -> LENGTH(t)
APP(cons(h, t), x) -> APP(t, x)
MAP_F(pid, cons(h, t)) -> APP(f(pid, h), map_f(pid, t))
MAP_F(pid, cons(h, t)) -> MAP_F(pid, t)
RING(st₁, in₂, st₂, in₃, st₃, m) -> IF₁(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₁)))
RING(st₁, in₂, st₂, in₃, st₃, m) -> EMPTY(fstsplit(m, st₁))
RING(st₁, in₂, st₂, in₃, st₃, m) -> FSTSPLIT(m, st₁)
RING(st₁, in₂, st₂, in₃, st₃, m) -> IF₂(st₁, in₂, st₂, in₃, st₃, m, leq(m, length(st₂)))
RING(st₁, in₂, st₂, in₃, st₃, m) -> LEQ(m, length(st₂))
RING(st₁, in₂, st₂, in₃, st₃, m) -> LENGTH(st₂)
RING(st₁, in₂, st₂, in₃, st₃, m) -> IF₅(st₁, in₂, st₂, in₃, st₃, m, empty(map_f(two, head(in₂))))
RING(st₁, in₂, st₂, in₃, st₃, m) -> EMPTY(map_f(two, head(in₂)))
RING(st₁, in₂, st₂, in₃, st₃, m) -> MAP_F(two, head(in₂))
RING(st₁, in₂, st₂, in₃, st₃, m) -> HEAD(in₂)
RING(st₁, in₂, st₂, in₃, st₃, m) -> IF₆(st₁, in₂, st₂, in₃, st₃, m, leq(m, length(st₃)))
RING(st₁, in₂, st₂, in₃, st₃, m) -> LEQ(m, length(st₃))
RING(st₁, in₂, st₂, in₃, st₃, m) -> LENGTH(st₃)
RING(st₁, in₂, st₂, in₃, st₃, m) -> IF₉(st₁, in₂, st₂, in₃, st₃, m, empty(map_f(three, head(in₃))))
RING(st₁, in₂, st₂, in₃, st₃, m) -> EMPTY(map_f(three, head(in₃)))
RING(st₁, in₂, st₂, in₃, st₃, m) -> MAP_F(three, head(in₃))
RING(st₁, in₂, st₂, in₃, st₃, m) -> HEAD(in₃)
IF₁(st₁, in₂, st₂, in₃, st₃, m, false) -> RING(sndsplit(m, st₁), cons(fstsplit(m, st₁), in₂), st₂, in₃, st₃, m)
IF₁(st₁, in₂, st₂, in₃, st₃, m, false) -> SNDSPLIT(m, st₁)
IF₁(st₁, in₂, st₂, in₃, st₃, m, false) -> FSTSPLIT(m, st₁)
IF₂(st₁, in₂, st₂, in₃, st₃, m, true) -> IF₃(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₂)))
IF₂(st₁, in₂, st₂, in₃, st₃, m, true) -> EMPTY(fstsplit(m, st₂))
IF₂(st₁, in₂, st₂, in₃, st₃, m, true) -> FSTSPLIT(m, st₂)
IF₂(st₁, in₂, st₂, in₃, st₃, m, false) -> IF₄(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, app(map_f(two, head(in₂)), st₂))))
IF₂(st₁, in₂, st₂, in₃, st₃, m, false) -> EMPTY(fstsplit(m, app(map_f(two, head(in₂)), st₂)))
IF₂(st₁, in₂, st₂, in₃, st₃, m, false) -> FSTSPLIT(m, app(map_f(two, head(in₂)), st₂))
IF₂(st₁, in₂, st₂, in₃, st₃, m, false) -> APP(map_f(two, head(in₂)), st₂)
IF₂(st₁, in₂, st₂, in₃, st₃, m, false) -> MAP_F(two, head(in₂))
IF₂(st₁, in₂, st₂, in₃, st₃, m, false) -> HEAD(in₂)
IF₃(st₁, in₂, st₂, in₃, st₃, m, false) -> RING(st₁, in₂, sndsplit(m, st₂), cons(fstsplit(m, st₂), in₃), st₃, m)
IF₃(st₁, in₂, st₂, in₃, st₃, m, false) -> SNDSPLIT(m, st₂)
IF₃(st₁, in₂, st₂, in₃, st₃, m, false) -> FSTSPLIT(m, st₂)
IF₄(st₁, in₂, st₂, in₃, st₃, m, false) -> RING(st₁, tail(in₂), sndsplit(m, app(map_f(two, head(in₂)), st₂)), cons(fstsplit(m, app(map_f(two, head(in₂)), st₂)), in₃), st₃, m)
IF₄(st₁, in₂, st₂, in₃, st₃, m, false) -> TAIL(in₂)
IF₄(st₁, in₂, st₂, in₃, st₃, m, false) -> SNDSPLIT(m, app(map_f(two, head(in₂)), st₂))
IF₄(st₁, in₂, st₂, in₃, st₃, m, false) -> APP(map_f(two, head(in₂)), st₂)
IF₄(st₁, in₂, st₂, in₃, st₃, m, false) -> MAP_F(two, head(in₂))
IF₄(st₁, in₂, st₂, in₃, st₃, m, false) -> HEAD(in₂)
IF₄(st₁, in₂, st₂, in₃, st₃, m, false) -> FSTSPLIT(m, app(map_f(two, head(in₂)), st₂))
IF₅(st₁, in₂, st₂, in₃, st₃, m, true) -> RING(st₁, tail(in₂), st₂, in₃, st₃, m)
IF₅(st₁, in₂, st₂, in₃, st₃, m, true) -> TAIL(in₂)
IF₆(st₁, in₂, st₂, in₃, st₃, m, true) -> IF₇(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₃)))
IF₆(st₁, in₂, st₂, in₃, st₃, m, true) -> EMPTY(fstsplit(m, st₃))
IF₆(st₁, in₂, st₂, in₃, st₃, m, true) -> FSTSPLIT(m, st₃)
IF₆(st₁, in₂, st₂, in₃, st₃, m, false) -> IF₈(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, app(map_f(three, head(in₃)), st₃))))
IF₆(st₁, in₂, st₂, in₃, st₃, m, false) -> EMPTY(fstsplit(m, app(map_f(three, head(in₃)), st₃)))
IF₆(st₁, in₂, st₂, in₃, st₃, m, false) -> FSTSPLIT(m, app(map_f(three, head(in₃)), st₃))
IF₆(st₁, in₂, st₂, in₃, st₃, m, false) -> APP(map_f(three, head(in₃)), st₃)
IF₆(st₁, in₂, st₂, in₃, st₃, m, false) -> MAP_F(three, head(in₃))
IF₆(st₁, in₂, st₂, in₃, st₃, m, false) -> HEAD(in₃)
IF₇(st₁, in₂, st₂, in₃, st₃, m, false) -> RING(st₁, in₂, st₂, in₃, sndsplit(m, st₃), m)
IF₇(st₁, in₂, st₂, in₃, st₃, m, false) -> SNDSPLIT(m, st₃)
IF₈(st₁, in₂, st₂, in₃, st₃, m, false) -> RING(st₁, in₂, st₂, tail(in₃), sndsplit(m, app(map_f(three, head(in₃)), st₃)), m)
IF₈(st₁, in₂, st₂, in₃, st₃, m, false) -> TAIL(in₃)
IF₈(st₁, in₂, st₂, in₃, st₃, m, false) -> SNDSPLIT(m, app(map_f(three, head(in₃)), st₃))
IF₈(st₁, in₂, st₂, in₃, st₃, m, false) -> APP(map_f(three, head(in₃)), st₃)
IF₈(st₁, in₂, st₂, in₃, st₃, m, false) -> MAP_F(three, head(in₃))
IF₈(st₁, in₂, st₂, in₃, st₃, m, false) -> HEAD(in₃)
IF₉(st₁, in₂, st₂, in₃, st₃, m, true) -> RING(st₁, in₂, st₂, tail(in₃), st₃, m)
IF₉(st₁, in₂, st₂, in₃, st₃, m, true) -> TAIL(in₃)

Furthermore, R contains seven SCCs.

     ↳DPs

       →DP Problem 1

         ↳Usable Rules (Innermost)

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

       →DP Problem 7

         ↳UsableRules

Dependency Pair:

FSTSPLIT(s(n), cons(h, t)) -> FSTSPLIT(n, t)

Rules:

fstsplit(0, x) -> nil
fstsplit(s(n), nil) -> nil
fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t))
sndsplit(0, x) -> x
sndsplit(s(n), nil) -> nil
sndsplit(s(n), cons(h, t)) -> sndsplit(n, t)
empty(nil) -> true
empty(cons(h, t)) -> false
leq(0, m) -> true
leq(s(n), 0) -> false
leq(s(n), s(m)) -> leq(n, m)
length(nil) -> 0
length(cons(h, t)) -> s(length(t))
app(nil, x) -> x
app(cons(h, t), x) -> cons(h, app(t, x))
map_f(pid, nil) -> nil
map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t))
head(cons(h, t)) -> h
tail(cons(h, t)) -> t
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₁(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₁)))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₂(st₁, in₂, st₂, in₃, st₃, m, leq(m, length(st₂)))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₅(st₁, in₂, st₂, in₃, st₃, m, empty(map_f(two, head(in₂))))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₆(st₁, in₂, st₂, in₃, st₃, m, leq(m, length(st₃)))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₉(st₁, in₂, st₂, in₃, st₃, m, empty(map_f(three, head(in₃))))
if₁(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(sndsplit(m, st₁), cons(fstsplit(m, st₁), in₂), st₂, in₃, st₃, m)
if₂(st₁, in₂, st₂, in₃, st₃, m, true) -> if₃(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₂)))
if₂(st₁, in₂, st₂, in₃, st₃, m, false) -> if₄(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, app(map_f(two, head(in₂)), st₂))))
if₃(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, in₂, sndsplit(m, st₂), cons(fstsplit(m, st₂), in₃), st₃, m)
if₄(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, tail(in₂), sndsplit(m, app(map_f(two, head(in₂)), st₂)), cons(fstsplit(m, app(map_f(two, head(in₂)), st₂)), in₃), st₃, m)
if₅(st₁, in₂, st₂, in₃, st₃, m, true) -> ring(st₁, tail(in₂), st₂, in₃, st₃, m)
if₆(st₁, in₂, st₂, in₃, st₃, m, true) -> if₇(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₃)))
if₆(st₁, in₂, st₂, in₃, st₃, m, false) -> if₈(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, app(map_f(three, head(in₃)), st₃))))
if₇(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, in₂, st₂, in₃, sndsplit(m, st₃), m)
if₈(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, in₂, st₂, tail(in₃), sndsplit(m, app(map_f(three, head(in₃)), st₃)), m)
if₉(st₁, in₂, st₂, in₃, st₃, m, true) -> ring(st₁, in₂, st₂, tail(in₃), st₃, m)

Strategy:

innermost

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

     ↳DPs

       →DP Problem 1

         ↳UsableRules

           →DP Problem 8

             ↳Size-Change Principle

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

       →DP Problem 7

         ↳UsableRules

Dependency Pair:

FSTSPLIT(s(n), cons(h, t)) -> FSTSPLIT(n, t)

Rule:

none

Strategy:

innermost

We number the DPs as follows:

FSTSPLIT(s(n), cons(h, t)) -> FSTSPLIT(n, t)

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:

cons(x₁, x₂) -> cons(x₁, x₂)
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

       →DP Problem 6

         ↳UsableRules

       →DP Problem 7

         ↳UsableRules

Dependency Pair:

SNDSPLIT(s(n), cons(h, t)) -> SNDSPLIT(n, t)

Rules:

fstsplit(0, x) -> nil
fstsplit(s(n), nil) -> nil
fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t))
sndsplit(0, x) -> x
sndsplit(s(n), nil) -> nil
sndsplit(s(n), cons(h, t)) -> sndsplit(n, t)
empty(nil) -> true
empty(cons(h, t)) -> false
leq(0, m) -> true
leq(s(n), 0) -> false
leq(s(n), s(m)) -> leq(n, m)
length(nil) -> 0
length(cons(h, t)) -> s(length(t))
app(nil, x) -> x
app(cons(h, t), x) -> cons(h, app(t, x))
map_f(pid, nil) -> nil
map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t))
head(cons(h, t)) -> h
tail(cons(h, t)) -> t
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₁(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₁)))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₂(st₁, in₂, st₂, in₃, st₃, m, leq(m, length(st₂)))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₅(st₁, in₂, st₂, in₃, st₃, m, empty(map_f(two, head(in₂))))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₆(st₁, in₂, st₂, in₃, st₃, m, leq(m, length(st₃)))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₉(st₁, in₂, st₂, in₃, st₃, m, empty(map_f(three, head(in₃))))
if₁(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(sndsplit(m, st₁), cons(fstsplit(m, st₁), in₂), st₂, in₃, st₃, m)
if₂(st₁, in₂, st₂, in₃, st₃, m, true) -> if₃(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₂)))
if₂(st₁, in₂, st₂, in₃, st₃, m, false) -> if₄(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, app(map_f(two, head(in₂)), st₂))))
if₃(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, in₂, sndsplit(m, st₂), cons(fstsplit(m, st₂), in₃), st₃, m)
if₄(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, tail(in₂), sndsplit(m, app(map_f(two, head(in₂)), st₂)), cons(fstsplit(m, app(map_f(two, head(in₂)), st₂)), in₃), st₃, m)
if₅(st₁, in₂, st₂, in₃, st₃, m, true) -> ring(st₁, tail(in₂), st₂, in₃, st₃, m)
if₆(st₁, in₂, st₂, in₃, st₃, m, true) -> if₇(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₃)))
if₆(st₁, in₂, st₂, in₃, st₃, m, false) -> if₈(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, app(map_f(three, head(in₃)), st₃))))
if₇(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, in₂, st₂, in₃, sndsplit(m, st₃), m)
if₈(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, in₂, st₂, tail(in₃), sndsplit(m, app(map_f(three, head(in₃)), st₃)), m)
if₉(st₁, in₂, st₂, in₃, st₃, m, true) -> ring(st₁, in₂, st₂, tail(in₃), st₃, m)

Strategy:

innermost

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

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

           →DP Problem 9

             ↳Size-Change Principle

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

       →DP Problem 7

         ↳UsableRules

Dependency Pair:

SNDSPLIT(s(n), cons(h, t)) -> SNDSPLIT(n, t)

Rule:

none

Strategy:

innermost

We number the DPs as follows:

SNDSPLIT(s(n), cons(h, t)) -> SNDSPLIT(n, t)

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:

cons(x₁, x₂) -> cons(x₁, x₂)
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

       →DP Problem 6

         ↳UsableRules

       →DP Problem 7

         ↳UsableRules

Dependency Pair:

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

Rules:

fstsplit(0, x) -> nil
fstsplit(s(n), nil) -> nil
fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t))
sndsplit(0, x) -> x
sndsplit(s(n), nil) -> nil
sndsplit(s(n), cons(h, t)) -> sndsplit(n, t)
empty(nil) -> true
empty(cons(h, t)) -> false
leq(0, m) -> true
leq(s(n), 0) -> false
leq(s(n), s(m)) -> leq(n, m)
length(nil) -> 0
length(cons(h, t)) -> s(length(t))
app(nil, x) -> x
app(cons(h, t), x) -> cons(h, app(t, x))
map_f(pid, nil) -> nil
map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t))
head(cons(h, t)) -> h
tail(cons(h, t)) -> t
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₁(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₁)))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₂(st₁, in₂, st₂, in₃, st₃, m, leq(m, length(st₂)))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₅(st₁, in₂, st₂, in₃, st₃, m, empty(map_f(two, head(in₂))))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₆(st₁, in₂, st₂, in₃, st₃, m, leq(m, length(st₃)))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₉(st₁, in₂, st₂, in₃, st₃, m, empty(map_f(three, head(in₃))))
if₁(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(sndsplit(m, st₁), cons(fstsplit(m, st₁), in₂), st₂, in₃, st₃, m)
if₂(st₁, in₂, st₂, in₃, st₃, m, true) -> if₃(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₂)))
if₂(st₁, in₂, st₂, in₃, st₃, m, false) -> if₄(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, app(map_f(two, head(in₂)), st₂))))
if₃(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, in₂, sndsplit(m, st₂), cons(fstsplit(m, st₂), in₃), st₃, m)
if₄(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, tail(in₂), sndsplit(m, app(map_f(two, head(in₂)), st₂)), cons(fstsplit(m, app(map_f(two, head(in₂)), st₂)), in₃), st₃, m)
if₅(st₁, in₂, st₂, in₃, st₃, m, true) -> ring(st₁, tail(in₂), st₂, in₃, st₃, m)
if₆(st₁, in₂, st₂, in₃, st₃, m, true) -> if₇(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₃)))
if₆(st₁, in₂, st₂, in₃, st₃, m, false) -> if₈(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, app(map_f(three, head(in₃)), st₃))))
if₇(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, in₂, st₂, in₃, sndsplit(m, st₃), m)
if₈(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, in₂, st₂, tail(in₃), sndsplit(m, app(map_f(three, head(in₃)), st₃)), m)
if₉(st₁, in₂, st₂, in₃, st₃, m, true) -> ring(st₁, in₂, st₂, tail(in₃), st₃, m)

Strategy:

innermost

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

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

           →DP Problem 10

             ↳Size-Change Principle

       →DP Problem 4

         ↳UsableRules

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

       →DP Problem 7

         ↳UsableRules

Dependency Pair:

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

Rule:

none

Strategy:

innermost

We number the DPs as follows:

LEQ(s(n), s(m)) -> LEQ(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

         ↳UsableRules

       →DP Problem 4

         ↳Usable Rules (Innermost)

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

       →DP Problem 7

         ↳UsableRules

Dependency Pair:

LENGTH(cons(h, t)) -> LENGTH(t)

Rules:

fstsplit(0, x) -> nil
fstsplit(s(n), nil) -> nil
fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t))
sndsplit(0, x) -> x
sndsplit(s(n), nil) -> nil
sndsplit(s(n), cons(h, t)) -> sndsplit(n, t)
empty(nil) -> true
empty(cons(h, t)) -> false
leq(0, m) -> true
leq(s(n), 0) -> false
leq(s(n), s(m)) -> leq(n, m)
length(nil) -> 0
length(cons(h, t)) -> s(length(t))
app(nil, x) -> x
app(cons(h, t), x) -> cons(h, app(t, x))
map_f(pid, nil) -> nil
map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t))
head(cons(h, t)) -> h
tail(cons(h, t)) -> t
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₁(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₁)))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₂(st₁, in₂, st₂, in₃, st₃, m, leq(m, length(st₂)))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₅(st₁, in₂, st₂, in₃, st₃, m, empty(map_f(two, head(in₂))))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₆(st₁, in₂, st₂, in₃, st₃, m, leq(m, length(st₃)))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₉(st₁, in₂, st₂, in₃, st₃, m, empty(map_f(three, head(in₃))))
if₁(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(sndsplit(m, st₁), cons(fstsplit(m, st₁), in₂), st₂, in₃, st₃, m)
if₂(st₁, in₂, st₂, in₃, st₃, m, true) -> if₃(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₂)))
if₂(st₁, in₂, st₂, in₃, st₃, m, false) -> if₄(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, app(map_f(two, head(in₂)), st₂))))
if₃(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, in₂, sndsplit(m, st₂), cons(fstsplit(m, st₂), in₃), st₃, m)
if₄(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, tail(in₂), sndsplit(m, app(map_f(two, head(in₂)), st₂)), cons(fstsplit(m, app(map_f(two, head(in₂)), st₂)), in₃), st₃, m)
if₅(st₁, in₂, st₂, in₃, st₃, m, true) -> ring(st₁, tail(in₂), st₂, in₃, st₃, m)
if₆(st₁, in₂, st₂, in₃, st₃, m, true) -> if₇(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₃)))
if₆(st₁, in₂, st₂, in₃, st₃, m, false) -> if₈(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, app(map_f(three, head(in₃)), st₃))))
if₇(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, in₂, st₂, in₃, sndsplit(m, st₃), m)
if₈(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, in₂, st₂, tail(in₃), sndsplit(m, app(map_f(three, head(in₃)), st₃)), m)
if₉(st₁, in₂, st₂, in₃, st₃, m, true) -> ring(st₁, in₂, st₂, tail(in₃), st₃, m)

Strategy:

innermost

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

     ↳DPs

       →DP Problem 1

         ↳UsableRules

       →DP Problem 2

         ↳UsableRules

       →DP Problem 3

         ↳UsableRules

       →DP Problem 4

         ↳UsableRules

           →DP Problem 11

             ↳Size-Change Principle

       →DP Problem 5

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

       →DP Problem 7

         ↳UsableRules

Dependency Pair:

LENGTH(cons(h, t)) -> LENGTH(t)

Rule:

none

Strategy:

innermost

We number the DPs as follows:

LENGTH(cons(h, t)) -> LENGTH(t)

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

{1}	,	{1}
1	>	1

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

{1}	,	{1}
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)

       →DP Problem 6

         ↳UsableRules

       →DP Problem 7

         ↳UsableRules

Dependency Pair:

APP(cons(h, t), x) -> APP(t, x)

Rules:

fstsplit(0, x) -> nil
fstsplit(s(n), nil) -> nil
fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t))
sndsplit(0, x) -> x
sndsplit(s(n), nil) -> nil
sndsplit(s(n), cons(h, t)) -> sndsplit(n, t)
empty(nil) -> true
empty(cons(h, t)) -> false
leq(0, m) -> true
leq(s(n), 0) -> false
leq(s(n), s(m)) -> leq(n, m)
length(nil) -> 0
length(cons(h, t)) -> s(length(t))
app(nil, x) -> x
app(cons(h, t), x) -> cons(h, app(t, x))
map_f(pid, nil) -> nil
map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t))
head(cons(h, t)) -> h
tail(cons(h, t)) -> t
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₁(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₁)))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₂(st₁, in₂, st₂, in₃, st₃, m, leq(m, length(st₂)))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₅(st₁, in₂, st₂, in₃, st₃, m, empty(map_f(two, head(in₂))))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₆(st₁, in₂, st₂, in₃, st₃, m, leq(m, length(st₃)))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₉(st₁, in₂, st₂, in₃, st₃, m, empty(map_f(three, head(in₃))))
if₁(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(sndsplit(m, st₁), cons(fstsplit(m, st₁), in₂), st₂, in₃, st₃, m)
if₂(st₁, in₂, st₂, in₃, st₃, m, true) -> if₃(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₂)))
if₂(st₁, in₂, st₂, in₃, st₃, m, false) -> if₄(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, app(map_f(two, head(in₂)), st₂))))
if₃(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, in₂, sndsplit(m, st₂), cons(fstsplit(m, st₂), in₃), st₃, m)
if₄(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, tail(in₂), sndsplit(m, app(map_f(two, head(in₂)), st₂)), cons(fstsplit(m, app(map_f(two, head(in₂)), st₂)), in₃), st₃, m)
if₅(st₁, in₂, st₂, in₃, st₃, m, true) -> ring(st₁, tail(in₂), st₂, in₃, st₃, m)
if₆(st₁, in₂, st₂, in₃, st₃, m, true) -> if₇(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₃)))
if₆(st₁, in₂, st₂, in₃, st₃, m, false) -> if₈(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, app(map_f(three, head(in₃)), st₃))))
if₇(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, in₂, st₂, in₃, sndsplit(m, st₃), m)
if₈(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, in₂, st₂, tail(in₃), sndsplit(m, app(map_f(three, head(in₃)), st₃)), m)
if₉(st₁, in₂, st₂, in₃, st₃, m, true) -> ring(st₁, in₂, st₂, tail(in₃), st₃, m)

Strategy:

innermost

As we are in the innermost case, we can delete all 35 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 12

             ↳Size-Change Principle

       →DP Problem 6

         ↳UsableRules

       →DP Problem 7

         ↳UsableRules

Dependency Pair:

APP(cons(h, t), x) -> APP(t, x)

Rule:

none

Strategy:

innermost

We number the DPs as follows:

APP(cons(h, t), x) -> APP(t, x)

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:

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

         ↳UsableRules

       →DP Problem 6

         ↳Usable Rules (Innermost)

       →DP Problem 7

         ↳UsableRules

Dependency Pair:

MAP_F(pid, cons(h, t)) -> MAP_F(pid, t)

Rules:

fstsplit(0, x) -> nil
fstsplit(s(n), nil) -> nil
fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t))
sndsplit(0, x) -> x
sndsplit(s(n), nil) -> nil
sndsplit(s(n), cons(h, t)) -> sndsplit(n, t)
empty(nil) -> true
empty(cons(h, t)) -> false
leq(0, m) -> true
leq(s(n), 0) -> false
leq(s(n), s(m)) -> leq(n, m)
length(nil) -> 0
length(cons(h, t)) -> s(length(t))
app(nil, x) -> x
app(cons(h, t), x) -> cons(h, app(t, x))
map_f(pid, nil) -> nil
map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t))
head(cons(h, t)) -> h
tail(cons(h, t)) -> t
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₁(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₁)))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₂(st₁, in₂, st₂, in₃, st₃, m, leq(m, length(st₂)))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₅(st₁, in₂, st₂, in₃, st₃, m, empty(map_f(two, head(in₂))))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₆(st₁, in₂, st₂, in₃, st₃, m, leq(m, length(st₃)))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₉(st₁, in₂, st₂, in₃, st₃, m, empty(map_f(three, head(in₃))))
if₁(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(sndsplit(m, st₁), cons(fstsplit(m, st₁), in₂), st₂, in₃, st₃, m)
if₂(st₁, in₂, st₂, in₃, st₃, m, true) -> if₃(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₂)))
if₂(st₁, in₂, st₂, in₃, st₃, m, false) -> if₄(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, app(map_f(two, head(in₂)), st₂))))
if₃(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, in₂, sndsplit(m, st₂), cons(fstsplit(m, st₂), in₃), st₃, m)
if₄(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, tail(in₂), sndsplit(m, app(map_f(two, head(in₂)), st₂)), cons(fstsplit(m, app(map_f(two, head(in₂)), st₂)), in₃), st₃, m)
if₅(st₁, in₂, st₂, in₃, st₃, m, true) -> ring(st₁, tail(in₂), st₂, in₃, st₃, m)
if₆(st₁, in₂, st₂, in₃, st₃, m, true) -> if₇(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₃)))
if₆(st₁, in₂, st₂, in₃, st₃, m, false) -> if₈(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, app(map_f(three, head(in₃)), st₃))))
if₇(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, in₂, st₂, in₃, sndsplit(m, st₃), m)
if₈(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, in₂, st₂, tail(in₃), sndsplit(m, app(map_f(three, head(in₃)), st₃)), m)
if₉(st₁, in₂, st₂, in₃, st₃, m, true) -> ring(st₁, in₂, st₂, tail(in₃), st₃, m)

Strategy:

innermost

As we are in the innermost case, we can delete all 35 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 6

         ↳UsableRules

           →DP Problem 13

             ↳Size-Change Principle

       →DP Problem 7

         ↳UsableRules

Dependency Pair:

MAP_F(pid, cons(h, t)) -> MAP_F(pid, t)

Rule:

none

Strategy:

innermost

We number the DPs as follows:

MAP_F(pid, cons(h, t)) -> MAP_F(pid, t)

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:

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

         ↳UsableRules

       →DP Problem 6

         ↳UsableRules

       →DP Problem 7

         ↳Usable Rules (Innermost)

Dependency Pairs:

IF₄(st₁, in₂, st₂, in₃, st₃, m, false) -> RING(st₁, tail(in₂), sndsplit(m, app(map_f(two, head(in₂)), st₂)), cons(fstsplit(m, app(map_f(two, head(in₂)), st₂)), in₃), st₃, m)
IF₂(st₁, in₂, st₂, in₃, st₃, m, false) -> IF₄(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, app(map_f(two, head(in₂)), st₂))))
IF₈(st₁, in₂, st₂, in₃, st₃, m, false) -> RING(st₁, in₂, st₂, tail(in₃), sndsplit(m, app(map_f(three, head(in₃)), st₃)), m)
IF₆(st₁, in₂, st₂, in₃, st₃, m, false) -> IF₈(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, app(map_f(three, head(in₃)), st₃))))
IF₉(st₁, in₂, st₂, in₃, st₃, m, true) -> RING(st₁, in₂, st₂, tail(in₃), st₃, m)
RING(st₁, in₂, st₂, in₃, st₃, m) -> IF₉(st₁, in₂, st₂, in₃, st₃, m, empty(map_f(three, head(in₃))))
IF₇(st₁, in₂, st₂, in₃, st₃, m, false) -> RING(st₁, in₂, st₂, in₃, sndsplit(m, st₃), m)
IF₆(st₁, in₂, st₂, in₃, st₃, m, true) -> IF₇(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₃)))
RING(st₁, in₂, st₂, in₃, st₃, m) -> IF₆(st₁, in₂, st₂, in₃, st₃, m, leq(m, length(st₃)))
IF₅(st₁, in₂, st₂, in₃, st₃, m, true) -> RING(st₁, tail(in₂), st₂, in₃, st₃, m)
RING(st₁, in₂, st₂, in₃, st₃, m) -> IF₅(st₁, in₂, st₂, in₃, st₃, m, empty(map_f(two, head(in₂))))
IF₃(st₁, in₂, st₂, in₃, st₃, m, false) -> RING(st₁, in₂, sndsplit(m, st₂), cons(fstsplit(m, st₂), in₃), st₃, m)
IF₂(st₁, in₂, st₂, in₃, st₃, m, true) -> IF₃(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₂)))
RING(st₁, in₂, st₂, in₃, st₃, m) -> IF₂(st₁, in₂, st₂, in₃, st₃, m, leq(m, length(st₂)))
IF₁(st₁, in₂, st₂, in₃, st₃, m, false) -> RING(sndsplit(m, st₁), cons(fstsplit(m, st₁), in₂), st₂, in₃, st₃, m)
RING(st₁, in₂, st₂, in₃, st₃, m) -> IF₁(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₁)))

Rules:

fstsplit(0, x) -> nil
fstsplit(s(n), nil) -> nil
fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t))
sndsplit(0, x) -> x
sndsplit(s(n), nil) -> nil
sndsplit(s(n), cons(h, t)) -> sndsplit(n, t)
empty(nil) -> true
empty(cons(h, t)) -> false
leq(0, m) -> true
leq(s(n), 0) -> false
leq(s(n), s(m)) -> leq(n, m)
length(nil) -> 0
length(cons(h, t)) -> s(length(t))
app(nil, x) -> x
app(cons(h, t), x) -> cons(h, app(t, x))
map_f(pid, nil) -> nil
map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t))
head(cons(h, t)) -> h
tail(cons(h, t)) -> t
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₁(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₁)))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₂(st₁, in₂, st₂, in₃, st₃, m, leq(m, length(st₂)))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₅(st₁, in₂, st₂, in₃, st₃, m, empty(map_f(two, head(in₂))))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₆(st₁, in₂, st₂, in₃, st₃, m, leq(m, length(st₃)))
ring(st₁, in₂, st₂, in₃, st₃, m) -> if₉(st₁, in₂, st₂, in₃, st₃, m, empty(map_f(three, head(in₃))))
if₁(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(sndsplit(m, st₁), cons(fstsplit(m, st₁), in₂), st₂, in₃, st₃, m)
if₂(st₁, in₂, st₂, in₃, st₃, m, true) -> if₃(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₂)))
if₂(st₁, in₂, st₂, in₃, st₃, m, false) -> if₄(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, app(map_f(two, head(in₂)), st₂))))
if₃(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, in₂, sndsplit(m, st₂), cons(fstsplit(m, st₂), in₃), st₃, m)
if₄(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, tail(in₂), sndsplit(m, app(map_f(two, head(in₂)), st₂)), cons(fstsplit(m, app(map_f(two, head(in₂)), st₂)), in₃), st₃, m)
if₅(st₁, in₂, st₂, in₃, st₃, m, true) -> ring(st₁, tail(in₂), st₂, in₃, st₃, m)
if₆(st₁, in₂, st₂, in₃, st₃, m, true) -> if₇(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, st₃)))
if₆(st₁, in₂, st₂, in₃, st₃, m, false) -> if₈(st₁, in₂, st₂, in₃, st₃, m, empty(fstsplit(m, app(map_f(three, head(in₃)), st₃))))
if₇(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, in₂, st₂, in₃, sndsplit(m, st₃), m)
if₈(st₁, in₂, st₂, in₃, st₃, m, false) -> ring(st₁, in₂, st₂, tail(in₃), sndsplit(m, app(map_f(three, head(in₃)), st₃)), m)
if₉(st₁, in₂, st₂, in₃, st₃, m, true) -> ring(st₁, in₂, st₂, tail(in₃), st₃, m)

Strategy:

innermost

As we are in the innermost case, we can delete all 16 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 6

         ↳UsableRules

       →DP Problem 7

         ↳UsableRules

           →DP Problem 14

             ↳Remaining Obligation(s)

The following remains to be proven:
Dependency Pairs:

Rules:

map_f(pid, nil) -> nil
map_f(pid, cons(h, t)) -> app(f(pid, h), map_f(pid, t))
head(cons(h, t)) -> h
tail(cons(h, t)) -> t
fstsplit(s(n), cons(h, t)) -> cons(h, fstsplit(n, t))
fstsplit(0, x) -> nil
fstsplit(s(n), nil) -> nil
sndsplit(0, x) -> x
sndsplit(s(n), nil) -> nil
sndsplit(s(n), cons(h, t)) -> sndsplit(n, t)
app(nil, x) -> x
app(cons(h, t), x) -> cons(h, app(t, x))
empty(cons(h, t)) -> false
empty(nil) -> true
length(cons(h, t)) -> s(length(t))
length(nil) -> 0
leq(0, m) -> true
leq(s(n), 0) -> false
leq(s(n), s(m)) -> leq(n, m)

Strategy:

innermost

The Proof could not be continued due to a Timeout.
Innermost Termination of R could not be shown.
Duration:
1:00 minutes