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))
mapf(pid, nil) -> nil
mapf(pid, cons(h, t)) -> app(f(pid, h), mapf(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(mapf(self, nil), store))))
if2(store, m, false) -> process(app(mapf(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(mapf(self, nil), store)), m)

Innermost Termination of R to be shown.

R
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)
MAPF(pid, cons(h, t)) -> APP(f(pid, h), mapf(pid, t))
MAPF(pid, cons(h, t)) -> MAPF(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(mapf(self, nil), store))))
IF1(store, m, false) -> EMPTY(fstsplit(m, app(mapf(self, nil), store)))
IF1(store, m, false) -> FSTSPLIT(m, app(mapf(self, nil), store))
IF1(store, m, false) -> APP(mapf(self, nil), store)
IF1(store, m, false) -> MAPF(self, nil)
IF2(store, m, false) -> PROCESS(app(mapf(self, nil), sndsplit(m, store)), m)
IF2(store, m, false) -> APP(mapf(self, nil), sndsplit(m, store))
IF2(store, m, false) -> MAPF(self, nil)
IF2(store, m, false) -> SNDSPLIT(m, store)
IF3(store, m, false) -> PROCESS(sndsplit(m, app(mapf(self, nil), store)), m)
IF3(store, m, false) -> SNDSPLIT(m, app(mapf(self, nil), store))
IF3(store, m, false) -> APP(mapf(self, nil), store)
IF3(store, m, false) -> MAPF(self, nil)

Furthermore, R contains seven SCCs.

R
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
Remaining

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))
mapf(pid, nil) -> nil
mapf(pid, cons(h, t)) -> app(f(pid, h), mapf(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(mapf(self, nil), store))))
if2(store, m, false) -> process(app(mapf(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(mapf(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 that need to be oriented.
Used ordering: Homeomorphic Embedding Order with EMB
resulting in one new DP problem.
Used Argument Filtering System:
FSTSPLIT(x1, x2) -> FSTSPLIT(x1, x2)
s(x1) -> s(x1)
cons(x1, x2) -> cons(x1, x2)

R
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
Remaining

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))
mapf(pid, nil) -> nil
mapf(pid, cons(h, t)) -> app(f(pid, h), mapf(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(mapf(self, nil), store))))
if2(store, m, false) -> process(app(mapf(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(mapf(self, nil), store)), m)

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

R
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
Remaining

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))
mapf(pid, nil) -> nil
mapf(pid, cons(h, t)) -> app(f(pid, h), mapf(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(mapf(self, nil), store))))
if2(store, m, false) -> process(app(mapf(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(mapf(self, nil), store)), m)

Strategy:

innermost

The following dependency pair can be strictly oriented:

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

There are no usable rules for innermost that need to be oriented.
Used ordering: Homeomorphic Embedding Order with EMB
resulting in one new DP problem.
Used Argument Filtering System:
SNDSPLIT(x1, x2) -> SNDSPLIT(x1, x2)
s(x1) -> s(x1)
cons(x1, x2) -> cons(x1, x2)

R
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
Remaining

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))
mapf(pid, nil) -> nil
mapf(pid, cons(h, t)) -> app(f(pid, h), mapf(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(mapf(self, nil), store))))
if2(store, m, false) -> process(app(mapf(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(mapf(self, nil), store)), m)

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

R
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
Remaining

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))
mapf(pid, nil) -> nil
mapf(pid, cons(h, t)) -> app(f(pid, h), mapf(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(mapf(self, nil), store))))
if2(store, m, false) -> process(app(mapf(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(mapf(self, nil), store)), m)

Strategy:

innermost

The following dependency pair can be strictly oriented:

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

There are no usable rules for innermost that need to be oriented.
Used ordering: Homeomorphic Embedding Order with EMB
resulting in one new DP problem.
Used Argument Filtering System:
LEQ(x1, x2) -> LEQ(x1, x2)
s(x1) -> s(x1)

R
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
Remaining

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))
mapf(pid, nil) -> nil
mapf(pid, cons(h, t)) -> app(f(pid, h), mapf(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(mapf(self, nil), store))))
if2(store, m, false) -> process(app(mapf(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(mapf(self, nil), store)), m)

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

R
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
Remaining

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))
mapf(pid, nil) -> nil
mapf(pid, cons(h, t)) -> app(f(pid, h), mapf(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(mapf(self, nil), store))))
if2(store, m, false) -> process(app(mapf(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(mapf(self, nil), store)), m)

Strategy:

innermost

The following dependency pair can be strictly oriented:

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

There are no usable rules for innermost that need to be oriented.
Used ordering: Homeomorphic Embedding Order with EMB
resulting in one new DP problem.
Used Argument Filtering System:
LENGTH(x1) -> LENGTH(x1)
cons(x1, x2) -> cons(x1, x2)

R
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
Remaining

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))
mapf(pid, nil) -> nil
mapf(pid, cons(h, t)) -> app(f(pid, h), mapf(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(mapf(self, nil), store))))
if2(store, m, false) -> process(app(mapf(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(mapf(self, nil), store)), m)

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

R
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
Remaining

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))
mapf(pid, nil) -> nil
mapf(pid, cons(h, t)) -> app(f(pid, h), mapf(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(mapf(self, nil), store))))
if2(store, m, false) -> process(app(mapf(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(mapf(self, nil), store)), m)

Strategy:

innermost

The following dependency pair can be strictly oriented:

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

There are no usable rules for innermost that need to be oriented.
Used ordering: Homeomorphic Embedding Order with EMB
resulting in one new DP problem.
Used Argument Filtering System:
APP(x1, x2) -> APP(x1, x2)
cons(x1, x2) -> cons(x1, x2)

R
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
Remaining

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))
mapf(pid, nil) -> nil
mapf(pid, cons(h, t)) -> app(f(pid, h), mapf(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(mapf(self, nil), store))))
if2(store, m, false) -> process(app(mapf(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(mapf(self, nil), store)), m)

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

R
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
Remaining

Dependency Pair:

MAPF(pid, cons(h, t)) -> MAPF(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))
mapf(pid, nil) -> nil
mapf(pid, cons(h, t)) -> app(f(pid, h), mapf(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(mapf(self, nil), store))))
if2(store, m, false) -> process(app(mapf(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(mapf(self, nil), store)), m)

Strategy:

innermost

The following dependency pair can be strictly oriented:

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

There are no usable rules for innermost that need to be oriented.
Used ordering: Homeomorphic Embedding Order with EMB
resulting in one new DP problem.
Used Argument Filtering System:
MAPF(x1, x2) -> MAPF(x1, x2)
cons(x1, x2) -> cons(x1, x2)

R
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
Remaining

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))
mapf(pid, nil) -> nil
mapf(pid, cons(h, t)) -> app(f(pid, h), mapf(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(mapf(self, nil), store))))
if2(store, m, false) -> process(app(mapf(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(mapf(self, nil), store)), m)

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

R
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
Remaining Obligation(s)

The following remains to be proven:
Dependency Pairs:

IF3(store, m, false) -> PROCESS(sndsplit(m, app(mapf(self, nil), store)), m)
IF1(store, m, false) -> IF3(store, m, empty(fstsplit(m, app(mapf(self, nil), store))))
IF2(store, m, false) -> PROCESS(app(mapf(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))
mapf(pid, nil) -> nil
mapf(pid, cons(h, t)) -> app(f(pid, h), mapf(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(mapf(self, nil), store))))
if2(store, m, false) -> process(app(mapf(self, nil), sndsplit(m, store)), m)
if3(store, m, false) -> process(sndsplit(m, app(mapf(self, nil), store)), m)

Strategy:

innermost

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