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)

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

         ↳Remaining Obligation(s)

       →DP Problem 2

         ↳Remaining Obligation(s)

       →DP Problem 3

         ↳Remaining Obligation(s)

       →DP Problem 4

         ↳Remaining Obligation(s)

       →DP Problem 5

         ↳Remaining Obligation(s)

       →DP Problem 6

         ↳Remaining Obligation(s)

       →DP Problem 7

         ↳Remaining Obligation(s)

The following remains to be proven:

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

     ↳DPs

       →DP Problem 1

         ↳Remaining Obligation(s)

       →DP Problem 2

         ↳Remaining Obligation(s)

       →DP Problem 3

         ↳Remaining Obligation(s)

       →DP Problem 4

         ↳Remaining Obligation(s)

       →DP Problem 5

         ↳Remaining Obligation(s)

       →DP Problem 6

         ↳Remaining Obligation(s)

       →DP Problem 7

         ↳Remaining Obligation(s)

The following remains to be proven:

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

     ↳DPs

       →DP Problem 1

         ↳Remaining Obligation(s)

       →DP Problem 2

         ↳Remaining Obligation(s)

       →DP Problem 3

         ↳Remaining Obligation(s)

       →DP Problem 4

         ↳Remaining Obligation(s)

       →DP Problem 5

         ↳Remaining Obligation(s)

       →DP Problem 6

         ↳Remaining Obligation(s)

       →DP Problem 7

         ↳Remaining Obligation(s)

The following remains to be proven:

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

     ↳DPs

       →DP Problem 1

         ↳Remaining Obligation(s)

       →DP Problem 2

         ↳Remaining Obligation(s)

       →DP Problem 3

         ↳Remaining Obligation(s)

       →DP Problem 4

         ↳Remaining Obligation(s)

       →DP Problem 5

         ↳Remaining Obligation(s)

       →DP Problem 6

         ↳Remaining Obligation(s)

       →DP Problem 7

         ↳Remaining Obligation(s)

The following remains to be proven:

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

     ↳DPs

       →DP Problem 1

         ↳Remaining Obligation(s)

       →DP Problem 2

         ↳Remaining Obligation(s)

       →DP Problem 3

         ↳Remaining Obligation(s)

       →DP Problem 4

         ↳Remaining Obligation(s)

       →DP Problem 5

         ↳Remaining Obligation(s)

       →DP Problem 6

         ↳Remaining Obligation(s)

       →DP Problem 7

         ↳Remaining Obligation(s)

The following remains to be proven:

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

     ↳DPs

       →DP Problem 1

         ↳Remaining Obligation(s)

       →DP Problem 2

         ↳Remaining Obligation(s)

       →DP Problem 3

         ↳Remaining Obligation(s)

       →DP Problem 4

         ↳Remaining Obligation(s)

       →DP Problem 5

         ↳Remaining Obligation(s)

       →DP Problem 6

         ↳Remaining Obligation(s)

       →DP Problem 7

         ↳Remaining Obligation(s)

The following remains to be proven:

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

     ↳DPs

       →DP Problem 1

         ↳Remaining Obligation(s)

       →DP Problem 2

         ↳Remaining Obligation(s)

       →DP Problem 3

         ↳Remaining Obligation(s)

       →DP Problem 4

         ↳Remaining Obligation(s)

       →DP Problem 5

         ↳Remaining Obligation(s)

       →DP Problem 6

         ↳Remaining Obligation(s)

       →DP Problem 7

         ↳Remaining Obligation(s)

The following remains to be proven:

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

Termination of R could not be shown.
Duration:
0:01 minutes