Termination Proof using AProVE

Term Rewriting System R:
[x, n, h, t, m, pid, store]
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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Innermost Termination of R to be shown.

     ↳Dependency Pair Analysis

R contains the following Dependency Pairs:

FSTSPLIT(s(n), cons(h, t)) -> FSTSPLIT(n, t)
SNDSPLIT(s(n), cons(h, t)) -> SNDSPLIT(n, t)
LEQ(s(n), s(m)) -> LEQ(n, m)
LENGTH(cons(h, t)) -> LENGTH(t)
APP(cons(h, t), x) -> APP(t, x)
MAP_F(pid, cons(h, t)) -> APP(f(pid, h), map_f(pid, t))
MAP_F(pid, cons(h, t)) -> MAP_F(pid, t)
PROCESS(store, m) -> IF1(store, m, leq(m, length(store)))
PROCESS(store, m) -> LEQ(m, length(store))
PROCESS(store, m) -> LENGTH(store)
IF1(store, m, true) -> IF2(store, m, empty(fstsplit(m, store)))
IF1(store, m, true) -> EMPTY(fstsplit(m, store))
IF1(store, m, true) -> FSTSPLIT(m, store)
IF1(store, m, false) -> IF3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
IF1(store, m, false) -> EMPTY(fstsplit(m, app(map_f(self, nil), store)))
IF1(store, m, false) -> FSTSPLIT(m, app(map_f(self, nil), store))
IF1(store, m, false) -> APP(map_f(self, nil), store)
IF1(store, m, false) -> MAP_F(self, nil)
IF2(store, m, false) -> PROCESS(app(map_f(self, nil), sndsplit(m, store)), m)
IF2(store, m, false) -> APP(map_f(self, nil), sndsplit(m, store))
IF2(store, m, false) -> MAP_F(self, nil)
IF2(store, m, false) -> SNDSPLIT(m, store)
IF3(store, m, false) -> PROCESS(sndsplit(m, app(map_f(self, nil), store)), m)
IF3(store, m, false) -> SNDSPLIT(m, app(map_f(self, nil), store))
IF3(store, m, false) -> APP(map_f(self, nil), store)
IF3(store, m, false) -> MAP_F(self, nil)

Furthermore, R contains seven SCCs.

     ↳DPs

       →DP Problem 1

         ↳Argument Filtering and Ordering

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

The following dependency pair can be strictly oriented:

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

There are no usable rules for innermost w.r.t. to the AFS that need to be oriented.
Used ordering: Homeomorphic Embedding Order with EMB
resulting in one new DP problem.
Used Argument Filtering System:

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

     ↳DPs

       →DP Problem 1

         ↳AFS

           →DP Problem 8

             ↳Dependency Graph

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

Dependency Pair:

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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳Argument Filtering and Ordering

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

The following dependency pair can be strictly oriented:

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

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

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

           →DP Problem 9

             ↳Dependency Graph

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

Dependency Pair:

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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳Argument Filtering and Ordering

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

The following dependency pair can be strictly oriented:

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

LEQ(x₁, x₂) -> LEQ(x₁, x₂)
s(x₁) -> s(x₁)

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

           →DP Problem 10

             ↳Dependency Graph

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

Dependency Pair:

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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳Argument Filtering and Ordering

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

The following dependency pair can be strictly oriented:

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

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

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

           →DP Problem 11

             ↳Dependency Graph

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

Dependency Pair:

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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳Argument Filtering and Ordering

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

The following dependency pair can be strictly oriented:

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

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

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

           →DP Problem 12

             ↳Dependency Graph

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

Dependency Pair:

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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳Argument Filtering and Ordering

       →DP Problem 7

         ↳Rw

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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

The following dependency pair can be strictly oriented:

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

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

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

           →DP Problem 13

             ↳Dependency Graph

       →DP Problem 7

         ↳Rw

Dependency Pair:

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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rewriting Transformation

Dependency Pairs:

IF3(store, m, false) -> PROCESS(sndsplit(m, app(map_f(self, nil), store)), m)
IF1(store, m, false) -> IF3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
IF2(store, m, false) -> PROCESS(app(map_f(self, nil), sndsplit(m, store)), m)
IF1(store, m, true) -> IF2(store, m, empty(fstsplit(m, store)))
PROCESS(store, m) -> IF1(store, m, leq(m, length(store)))

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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

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

IF1(store, m, false) -> IF3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))

one new Dependency Pair is created:

IF1(store, m, false) -> IF3(store, m, empty(fstsplit(m, app(nil, store))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

           →DP Problem 14

             ↳Rewriting Transformation

Dependency Pairs:

IF1(store, m, false) -> IF3(store, m, empty(fstsplit(m, app(nil, store))))
IF2(store, m, false) -> PROCESS(app(map_f(self, nil), sndsplit(m, store)), m)
IF1(store, m, true) -> IF2(store, m, empty(fstsplit(m, store)))
PROCESS(store, m) -> IF1(store, m, leq(m, length(store)))
IF3(store, m, false) -> PROCESS(sndsplit(m, app(map_f(self, nil), store)), 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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

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

IF2(store, m, false) -> PROCESS(app(map_f(self, nil), sndsplit(m, store)), m)

one new Dependency Pair is created:

IF2(store, m, false) -> PROCESS(app(nil, sndsplit(m, store)), m)

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

           →DP Problem 14

             ↳Rw

...

               →DP Problem 15

                 ↳Rewriting Transformation

Dependency Pairs:

IF2(store, m, false) -> PROCESS(app(nil, sndsplit(m, store)), m)
IF1(store, m, true) -> IF2(store, m, empty(fstsplit(m, store)))
PROCESS(store, m) -> IF1(store, m, leq(m, length(store)))
IF3(store, m, false) -> PROCESS(sndsplit(m, app(map_f(self, nil), store)), m)
IF1(store, m, false) -> IF3(store, m, empty(fstsplit(m, app(nil, store))))

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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

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

IF3(store, m, false) -> PROCESS(sndsplit(m, app(map_f(self, nil), store)), m)

one new Dependency Pair is created:

IF3(store, m, false) -> PROCESS(sndsplit(m, app(nil, store)), m)

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

           →DP Problem 14

             ↳Rw

...

               →DP Problem 16

                 ↳Rewriting Transformation

Dependency Pairs:

IF3(store, m, false) -> PROCESS(sndsplit(m, app(nil, store)), m)
IF1(store, m, false) -> IF3(store, m, empty(fstsplit(m, app(nil, store))))
IF1(store, m, true) -> IF2(store, m, empty(fstsplit(m, store)))
PROCESS(store, m) -> IF1(store, m, leq(m, length(store)))
IF2(store, m, false) -> PROCESS(app(nil, sndsplit(m, store)), 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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

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

IF1(store, m, false) -> IF3(store, m, empty(fstsplit(m, app(nil, store))))

one new Dependency Pair is created:

IF1(store, m, false) -> IF3(store, m, empty(fstsplit(m, store)))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

           →DP Problem 14

             ↳Rw

...

               →DP Problem 17

                 ↳Rewriting Transformation

Dependency Pairs:

IF1(store, m, false) -> IF3(store, m, empty(fstsplit(m, store)))
IF2(store, m, false) -> PROCESS(app(nil, sndsplit(m, store)), m)
IF1(store, m, true) -> IF2(store, m, empty(fstsplit(m, store)))
PROCESS(store, m) -> IF1(store, m, leq(m, length(store)))
IF3(store, m, false) -> PROCESS(sndsplit(m, app(nil, store)), 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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

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

IF2(store, m, false) -> PROCESS(app(nil, sndsplit(m, store)), m)

one new Dependency Pair is created:

IF2(store, m, false) -> PROCESS(sndsplit(m, store), m)

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

           →DP Problem 14

             ↳Rw

...

               →DP Problem 18

                 ↳Rewriting Transformation

Dependency Pairs:

IF2(store, m, false) -> PROCESS(sndsplit(m, store), m)
IF1(store, m, true) -> IF2(store, m, empty(fstsplit(m, store)))
PROCESS(store, m) -> IF1(store, m, leq(m, length(store)))
IF3(store, m, false) -> PROCESS(sndsplit(m, app(nil, store)), m)
IF1(store, m, false) -> IF3(store, m, empty(fstsplit(m, store)))

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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

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

IF3(store, m, false) -> PROCESS(sndsplit(m, app(nil, store)), m)

one new Dependency Pair is created:

IF3(store, m, false) -> PROCESS(sndsplit(m, store), m)

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

           →DP Problem 14

             ↳Rw

...

               →DP Problem 19

                 ↳Narrowing Transformation

Dependency Pairs:

IF3(store, m, false) -> PROCESS(sndsplit(m, store), m)
IF1(store, m, false) -> IF3(store, m, empty(fstsplit(m, store)))
IF1(store, m, true) -> IF2(store, m, empty(fstsplit(m, store)))
PROCESS(store, m) -> IF1(store, m, leq(m, length(store)))
IF2(store, m, false) -> PROCESS(sndsplit(m, store), 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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

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

PROCESS(store, m) -> IF1(store, m, leq(m, length(store)))

three new Dependency Pairs are created:

PROCESS(store', 0) -> IF1(store', 0, true)
PROCESS(nil, m) -> IF1(nil, m, leq(m, 0))
PROCESS(cons(h', t'), m) -> IF1(cons(h', t'), m, leq(m, s(length(t'))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

           →DP Problem 14

             ↳Rw

...

               →DP Problem 20

                 ↳Narrowing Transformation

Dependency Pairs:

PROCESS(cons(h', t'), m) -> IF1(cons(h', t'), m, leq(m, s(length(t'))))
IF1(store, m, false) -> IF3(store, m, empty(fstsplit(m, store)))
PROCESS(nil, m) -> IF1(nil, m, leq(m, 0))
IF2(store, m, false) -> PROCESS(sndsplit(m, store), m)
IF1(store, m, true) -> IF2(store, m, empty(fstsplit(m, store)))
PROCESS(store', 0) -> IF1(store', 0, true)
IF3(store, m, false) -> PROCESS(sndsplit(m, store), 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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

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

IF1(store, m, true) -> IF2(store, m, empty(fstsplit(m, store)))

three new Dependency Pairs are created:

IF1(store', 0, true) -> IF2(store', 0, empty(nil))
IF1(nil, s(n'), true) -> IF2(nil, s(n'), empty(nil))
IF1(cons(h', t'), s(n'), true) -> IF2(cons(h', t'), s(n'), empty(cons(h', fstsplit(n', t'))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

           →DP Problem 14

             ↳Rw

...

               →DP Problem 21

                 ↳Rewriting Transformation

Dependency Pairs:

IF1(cons(h', t'), s(n'), true) -> IF2(cons(h', t'), s(n'), empty(cons(h', fstsplit(n', t'))))
IF1(nil, s(n'), true) -> IF2(nil, s(n'), empty(nil))
PROCESS(nil, m) -> IF1(nil, m, leq(m, 0))
IF2(store, m, false) -> PROCESS(sndsplit(m, store), m)
IF1(store', 0, true) -> IF2(store', 0, empty(nil))
PROCESS(store', 0) -> IF1(store', 0, true)
IF3(store, m, false) -> PROCESS(sndsplit(m, store), m)
IF1(store, m, false) -> IF3(store, m, empty(fstsplit(m, store)))
PROCESS(cons(h', t'), m) -> IF1(cons(h', t'), m, leq(m, s(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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

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

IF1(store', 0, true) -> IF2(store', 0, empty(nil))

one new Dependency Pair is created:

IF1(store', 0, true) -> IF2(store', 0, true)

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

           →DP Problem 14

             ↳Rw

...

               →DP Problem 22

                 ↳Rewriting Transformation

Dependency Pairs:

IF1(nil, s(n'), true) -> IF2(nil, s(n'), empty(nil))
PROCESS(cons(h', t'), m) -> IF1(cons(h', t'), m, leq(m, s(length(t'))))
IF3(store, m, false) -> PROCESS(sndsplit(m, store), m)
IF1(store, m, false) -> IF3(store, m, empty(fstsplit(m, store)))
PROCESS(nil, m) -> IF1(nil, m, leq(m, 0))
IF2(store, m, false) -> PROCESS(sndsplit(m, store), m)
IF1(cons(h', t'), s(n'), true) -> IF2(cons(h', t'), s(n'), empty(cons(h', 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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

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

IF1(nil, s(n'), true) -> IF2(nil, s(n'), empty(nil))

one new Dependency Pair is created:

IF1(nil, s(n'), true) -> IF2(nil, s(n'), true)

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

           →DP Problem 14

             ↳Rw

...

               →DP Problem 23

                 ↳Rewriting Transformation

Dependency Pairs:

IF2(store, m, false) -> PROCESS(sndsplit(m, store), m)
IF1(cons(h', t'), s(n'), true) -> IF2(cons(h', t'), s(n'), empty(cons(h', fstsplit(n', t'))))
PROCESS(nil, m) -> IF1(nil, m, leq(m, 0))
IF3(store, m, false) -> PROCESS(sndsplit(m, store), m)
IF1(store, m, false) -> IF3(store, m, empty(fstsplit(m, store)))
PROCESS(cons(h', t'), m) -> IF1(cons(h', t'), m, leq(m, s(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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

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

IF1(cons(h', t'), s(n'), true) -> IF2(cons(h', t'), s(n'), empty(cons(h', fstsplit(n', t'))))

one new Dependency Pair is created:

IF1(cons(h', t'), s(n'), true) -> IF2(cons(h', t'), s(n'), false)

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

           →DP Problem 14

             ↳Rw

...

               →DP Problem 24

                 ↳Narrowing Transformation

Dependency Pairs:

IF1(cons(h', t'), s(n'), true) -> IF2(cons(h', t'), s(n'), false)
PROCESS(cons(h', t'), m) -> IF1(cons(h', t'), m, leq(m, s(length(t'))))
IF3(store, m, false) -> PROCESS(sndsplit(m, store), m)
IF1(store, m, false) -> IF3(store, m, empty(fstsplit(m, store)))
PROCESS(nil, m) -> IF1(nil, m, leq(m, 0))
IF2(store, m, false) -> PROCESS(sndsplit(m, store), 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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

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

IF1(store, m, false) -> IF3(store, m, empty(fstsplit(m, store)))

three new Dependency Pairs are created:

IF1(store', 0, false) -> IF3(store', 0, empty(nil))
IF1(nil, s(n'), false) -> IF3(nil, s(n'), empty(nil))
IF1(cons(h', t'), s(n'), false) -> IF3(cons(h', t'), s(n'), empty(cons(h', fstsplit(n', t'))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

           →DP Problem 14

             ↳Rw

...

               →DP Problem 25

                 ↳Rewriting Transformation

Dependency Pairs:

IF1(nil, s(n'), false) -> IF3(nil, s(n'), empty(nil))
IF1(cons(h', t'), s(n'), false) -> IF3(cons(h', t'), s(n'), empty(cons(h', fstsplit(n', t'))))
PROCESS(cons(h', t'), m) -> IF1(cons(h', t'), m, leq(m, s(length(t'))))
IF3(store, m, false) -> PROCESS(sndsplit(m, store), m)
IF1(store', 0, false) -> IF3(store', 0, empty(nil))
PROCESS(nil, m) -> IF1(nil, m, leq(m, 0))
IF2(store, m, false) -> PROCESS(sndsplit(m, store), m)
IF1(cons(h', t'), s(n'), true) -> IF2(cons(h', t'), s(n'), false)

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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

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

IF1(store', 0, false) -> IF3(store', 0, empty(nil))

one new Dependency Pair is created:

IF1(store', 0, false) -> IF3(store', 0, true)

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

           →DP Problem 14

             ↳Rw

...

               →DP Problem 26

                 ↳Rewriting Transformation

Dependency Pairs:

IF1(cons(h', t'), s(n'), false) -> IF3(cons(h', t'), s(n'), empty(cons(h', fstsplit(n', t'))))
IF2(store, m, false) -> PROCESS(sndsplit(m, store), m)
IF1(cons(h', t'), s(n'), true) -> IF2(cons(h', t'), s(n'), false)
PROCESS(cons(h', t'), m) -> IF1(cons(h', t'), m, leq(m, s(length(t'))))
PROCESS(nil, m) -> IF1(nil, m, leq(m, 0))
IF3(store, m, false) -> PROCESS(sndsplit(m, store), m)
IF1(nil, s(n'), false) -> IF3(nil, s(n'), empty(nil))

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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

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

IF1(nil, s(n'), false) -> IF3(nil, s(n'), empty(nil))

one new Dependency Pair is created:

IF1(nil, s(n'), false) -> IF3(nil, s(n'), true)

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

           →DP Problem 14

             ↳Rw

...

               →DP Problem 27

                 ↳Rewriting Transformation

Dependency Pairs:

IF2(store, m, false) -> PROCESS(sndsplit(m, store), m)
IF1(cons(h', t'), s(n'), true) -> IF2(cons(h', t'), s(n'), false)
PROCESS(cons(h', t'), m) -> IF1(cons(h', t'), m, leq(m, s(length(t'))))
IF3(store, m, false) -> PROCESS(sndsplit(m, store), m)
IF1(cons(h', t'), s(n'), false) -> IF3(cons(h', t'), s(n'), empty(cons(h', 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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

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

IF1(cons(h', t'), s(n'), false) -> IF3(cons(h', t'), s(n'), empty(cons(h', fstsplit(n', t'))))

one new Dependency Pair is created:

IF1(cons(h', t'), s(n'), false) -> IF3(cons(h', t'), s(n'), false)

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

           →DP Problem 14

             ↳Rw

...

               →DP Problem 28

                 ↳Narrowing Transformation

Dependency Pairs:

IF3(store, m, false) -> PROCESS(sndsplit(m, store), m)
IF1(cons(h', t'), s(n'), false) -> IF3(cons(h', t'), s(n'), false)
IF1(cons(h', t'), s(n'), true) -> IF2(cons(h', t'), s(n'), false)
PROCESS(cons(h', t'), m) -> IF1(cons(h', t'), m, leq(m, s(length(t'))))
IF2(store, m, false) -> PROCESS(sndsplit(m, store), 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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

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

IF2(store, m, false) -> PROCESS(sndsplit(m, store), m)

three new Dependency Pairs are created:

IF2(store', 0, false) -> PROCESS(store', 0)
IF2(nil, s(n'), false) -> PROCESS(nil, s(n'))
IF2(cons(h', t'), s(n'), false) -> PROCESS(sndsplit(n', t'), s(n'))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

           →DP Problem 14

             ↳Rw

...

               →DP Problem 29

                 ↳Narrowing Transformation

Dependency Pairs:

IF1(cons(h', t'), s(n'), false) -> IF3(cons(h', t'), s(n'), false)
IF2(cons(h', t'), s(n'), false) -> PROCESS(sndsplit(n', t'), s(n'))
IF1(cons(h', t'), s(n'), true) -> IF2(cons(h', t'), s(n'), false)
PROCESS(cons(h', t'), m) -> IF1(cons(h', t'), m, leq(m, s(length(t'))))
IF3(store, m, false) -> PROCESS(sndsplit(m, store), 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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

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

IF3(store, m, false) -> PROCESS(sndsplit(m, store), m)

three new Dependency Pairs are created:

IF3(store', 0, false) -> PROCESS(store', 0)
IF3(nil, s(n'), false) -> PROCESS(nil, s(n'))
IF3(cons(h', t'), s(n'), false) -> PROCESS(sndsplit(n', t'), s(n'))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

           →DP Problem 14

             ↳Rw

...

               →DP Problem 30

                 ↳Instantiation Transformation

Dependency Pairs:

IF2(cons(h', t'), s(n'), false) -> PROCESS(sndsplit(n', t'), s(n'))
IF1(cons(h', t'), s(n'), true) -> IF2(cons(h', t'), s(n'), false)
PROCESS(cons(h', t'), m) -> IF1(cons(h', t'), m, leq(m, s(length(t'))))
IF3(cons(h', t'), s(n'), false) -> PROCESS(sndsplit(n', t'), s(n'))
IF1(cons(h', t'), s(n'), false) -> IF3(cons(h', t'), s(n'), false)

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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

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

PROCESS(cons(h', t'), m) -> IF1(cons(h', t'), m, leq(m, s(length(t'))))

one new Dependency Pair is created:

PROCESS(cons(h'', t''), s(n''')) -> IF1(cons(h'', t''), s(n'''), leq(s(n'''), s(length(t''))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

           →DP Problem 14

             ↳Rw

...

               →DP Problem 31

                 ↳Rewriting Transformation

Dependency Pairs:

IF3(cons(h', t'), s(n'), false) -> PROCESS(sndsplit(n', t'), s(n'))
IF1(cons(h', t'), s(n'), false) -> IF3(cons(h', t'), s(n'), false)
IF1(cons(h', t'), s(n'), true) -> IF2(cons(h', t'), s(n'), false)
PROCESS(cons(h'', t''), s(n''')) -> IF1(cons(h'', t''), s(n'''), leq(s(n'''), s(length(t''))))
IF2(cons(h', t'), s(n'), false) -> PROCESS(sndsplit(n', t'), s(n'))

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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

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

PROCESS(cons(h'', t''), s(n''')) -> IF1(cons(h'', t''), s(n'''), leq(s(n'''), s(length(t''))))

one new Dependency Pair is created:

PROCESS(cons(h'', t''), s(n''')) -> IF1(cons(h'', t''), s(n'''), leq(n''', length(t'')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

           →DP Problem 14

             ↳Rw

...

               →DP Problem 32

                 ↳Argument Filtering and Ordering

Dependency Pairs:

IF1(cons(h', t'), s(n'), false) -> IF3(cons(h', t'), s(n'), false)
IF2(cons(h', t'), s(n'), false) -> PROCESS(sndsplit(n', t'), s(n'))
IF1(cons(h', t'), s(n'), true) -> IF2(cons(h', t'), s(n'), false)
PROCESS(cons(h'', t''), s(n''')) -> IF1(cons(h'', t''), s(n'''), leq(n''', length(t'')))
IF3(cons(h', t'), s(n'), false) -> PROCESS(sndsplit(n', t'), s(n'))

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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

The following dependency pairs can be strictly oriented:

IF2(cons(h', t'), s(n'), false) -> PROCESS(sndsplit(n', t'), s(n'))
IF3(cons(h', t'), s(n'), false) -> PROCESS(sndsplit(n', t'), s(n'))

The following usable rules for innermost w.r.t. to the AFS can be oriented:

sndsplit(0, x) -> x
sndsplit(s(n), nil) -> nil
sndsplit(s(n), cons(h, t)) -> sndsplit(n, t)

Used ordering: Homeomorphic Embedding Order with EMB
resulting in one new DP problem.
Used Argument Filtering System:

IF3(x₁, x₂, x₃) -> x₁
cons(x₁, x₂) -> cons(x₁, x₂)
PROCESS(x₁, x₂) -> x₁
sndsplit(x₁, x₂) -> x₂
IF1(x₁, x₂, x₃) -> x₁
IF2(x₁, x₂, x₃) -> x₁

     ↳DPs

       →DP Problem 1

         ↳AFS

       →DP Problem 2

         ↳AFS

       →DP Problem 3

         ↳AFS

       →DP Problem 4

         ↳AFS

       →DP Problem 5

         ↳AFS

       →DP Problem 6

         ↳AFS

       →DP Problem 7

         ↳Rw

           →DP Problem 14

             ↳Rw

...

               →DP Problem 33

                 ↳Dependency Graph

Dependency Pairs:

IF1(cons(h', t'), s(n'), false) -> IF3(cons(h', t'), s(n'), false)
IF1(cons(h', t'), s(n'), true) -> IF2(cons(h', t'), s(n'), false)
PROCESS(cons(h'', t''), s(n''')) -> IF1(cons(h'', t''), s(n'''), leq(n''', 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))
process(store, m) -> if1(store, m, leq(m, length(store)))
if1(store, m, true) -> if2(store, m, empty(fstsplit(m, store)))
if1(store, m, false) -> if3(store, m, empty(fstsplit(m, app(map_f(self, nil), store))))
if2(store, m, false) -> process(app(map_f(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(map_f(self, nil), store)), m)

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

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