0 QTRS
↳1 Overlay + Local Confluence (⇔)
↳2 QTRS
↳3 DependencyPairsProof (⇔)
↳4 QDP
↳5 DependencyGraphProof (⇔)
↳6 AND
↳7 QDP
↳8 UsableRulesProof (⇔)
↳9 QDP
↳10 QReductionProof (⇔)
↳11 QDP
↳12 QDPSizeChangeProof (⇔)
↳13 TRUE
↳14 QDP
↳15 UsableRulesProof (⇔)
↳16 QDP
↳17 QReductionProof (⇔)
↳18 QDP
↳19 QDPSizeChangeProof (⇔)
↳20 TRUE
↳21 QDP
↳22 UsableRulesProof (⇔)
↳23 QDP
↳24 QReductionProof (⇔)
↳25 QDP
↳26 QDPOrderProof (⇔)
↳27 QDP
↳28 DependencyGraphProof (⇔)
↳29 TRUE
↳30 QDP
↳31 UsableRulesProof (⇔)
↳32 QDP
↳33 QReductionProof (⇔)
↳34 QDP
↳35 QDPSizeChangeProof (⇔)
↳36 TRUE
↳37 QDP
↳38 UsableRulesProof (⇔)
↳39 QDP
↳40 QReductionProof (⇔)
↳41 QDP
↳42 QDPSizeChangeProof (⇔)
↳43 TRUE
↳44 QDP
↳45 UsableRulesProof (⇔)
↳46 QDP
↳47 QReductionProof (⇔)
↳48 QDP
↳49 Instantiation (⇔)
↳50 QDP
↳51 Narrowing (⇔)
↳52 QDP
↳53 DependencyGraphProof (⇔)
↳54 QDP
↳55 UsableRulesProof (⇔)
↳56 QDP
↳57 QReductionProof (⇔)
↳58 QDP
↳59 Narrowing (⇔)
↳60 QDP
↳61 Rewriting (⇔)
↳62 QDP
↳63 Rewriting (⇔)
↳64 QDP
↳65 Rewriting (⇔)
↳66 QDP
↳67 Rewriting (⇔)
↳68 QDP
↳69 Rewriting (⇔)
↳70 QDP
↳71 Narrowing (⇔)
↳72 QDP
↳73 DependencyGraphProof (⇔)
↳74 QDP
↳75 UsableRulesProof (⇔)
↳76 QDP
↳77 QReductionProof (⇔)
↳78 QDP
↳79 Rewriting (⇔)
↳80 QDP
↳81 Instantiation (⇔)
↳82 QDP
↳83 DependencyGraphProof (⇔)
↳84 QDP
↳85 Rewriting (⇔)
↳86 QDP
↳87 UsableRulesProof (⇔)
↳88 QDP
↳89 QReductionProof (⇔)
↳90 QDP
↳91 QDPOrderProof (⇔)
↳92 QDP
↳93 UsableRulesProof (⇔)
↳94 QDP
↳95 QReductionProof (⇔)
↳96 QDP
↳97 QDPSizeChangeProof (⇔)
↳98 TRUE
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) → min(add(n, x))
if_min(false, add(n, add(m, x))) → min(add(m, x))
head(add(n, x)) → n
tail(add(n, x)) → x
tail(nil) → nil
null(nil) → true
null(add(n, x)) → false
rm(n, nil) → nil
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) → rm(n, x)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
minsort(x) → mins(x, nil, nil)
mins(x, y, z) → if(null(x), x, y, z)
if(true, x, y, z) → z
if(false, x, y, z) → if2(eq(head(x), min(x)), x, y, z)
if2(true, x, y, z) → mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil)))
if2(false, x, y, z) → mins(tail(x), add(head(x), y), z)
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) → min(add(n, x))
if_min(false, add(n, add(m, x))) → min(add(m, x))
head(add(n, x)) → n
tail(add(n, x)) → x
tail(nil) → nil
null(nil) → true
null(add(n, x)) → false
rm(n, nil) → nil
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) → rm(n, x)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
minsort(x) → mins(x, nil, nil)
mins(x, y, z) → if(null(x), x, y, z)
if(true, x, y, z) → z
if(false, x, y, z) → if2(eq(head(x), min(x)), x, y, z)
if2(true, x, y, z) → mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil)))
if2(false, x, y, z) → mins(tail(x), add(head(x), y), z)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
null(nil)
null(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
minsort(x0)
mins(x0, x1, x2)
if(true, x0, x1, x2)
if(false, x0, x1, x2)
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
EQ(s(x), s(y)) → EQ(x, y)
LE(s(x), s(y)) → LE(x, y)
APP(add(n, x), y) → APP(x, y)
MIN(add(n, add(m, x))) → IF_MIN(le(n, m), add(n, add(m, x)))
MIN(add(n, add(m, x))) → LE(n, m)
IF_MIN(true, add(n, add(m, x))) → MIN(add(n, x))
IF_MIN(false, add(n, add(m, x))) → MIN(add(m, x))
RM(n, add(m, x)) → IF_RM(eq(n, m), n, add(m, x))
RM(n, add(m, x)) → EQ(n, m)
IF_RM(true, n, add(m, x)) → RM(n, x)
IF_RM(false, n, add(m, x)) → RM(n, x)
MINSORT(x) → MINS(x, nil, nil)
MINS(x, y, z) → IF(null(x), x, y, z)
MINS(x, y, z) → NULL(x)
IF(false, x, y, z) → IF2(eq(head(x), min(x)), x, y, z)
IF(false, x, y, z) → EQ(head(x), min(x))
IF(false, x, y, z) → HEAD(x)
IF(false, x, y, z) → MIN(x)
IF2(true, x, y, z) → MINS(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil)))
IF2(true, x, y, z) → APP(rm(head(x), tail(x)), y)
IF2(true, x, y, z) → RM(head(x), tail(x))
IF2(true, x, y, z) → HEAD(x)
IF2(true, x, y, z) → TAIL(x)
IF2(true, x, y, z) → APP(z, add(head(x), nil))
IF2(false, x, y, z) → MINS(tail(x), add(head(x), y), z)
IF2(false, x, y, z) → TAIL(x)
IF2(false, x, y, z) → HEAD(x)
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) → min(add(n, x))
if_min(false, add(n, add(m, x))) → min(add(m, x))
head(add(n, x)) → n
tail(add(n, x)) → x
tail(nil) → nil
null(nil) → true
null(add(n, x)) → false
rm(n, nil) → nil
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) → rm(n, x)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
minsort(x) → mins(x, nil, nil)
mins(x, y, z) → if(null(x), x, y, z)
if(true, x, y, z) → z
if(false, x, y, z) → if2(eq(head(x), min(x)), x, y, z)
if2(true, x, y, z) → mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil)))
if2(false, x, y, z) → mins(tail(x), add(head(x), y), z)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
null(nil)
null(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
minsort(x0)
mins(x0, x1, x2)
if(true, x0, x1, x2)
if(false, x0, x1, x2)
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
APP(add(n, x), y) → APP(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) → min(add(n, x))
if_min(false, add(n, add(m, x))) → min(add(m, x))
head(add(n, x)) → n
tail(add(n, x)) → x
tail(nil) → nil
null(nil) → true
null(add(n, x)) → false
rm(n, nil) → nil
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) → rm(n, x)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
minsort(x) → mins(x, nil, nil)
mins(x, y, z) → if(null(x), x, y, z)
if(true, x, y, z) → z
if(false, x, y, z) → if2(eq(head(x), min(x)), x, y, z)
if2(true, x, y, z) → mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil)))
if2(false, x, y, z) → mins(tail(x), add(head(x), y), z)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
null(nil)
null(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
minsort(x0)
mins(x0, x1, x2)
if(true, x0, x1, x2)
if(false, x0, x1, x2)
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
APP(add(n, x), y) → APP(x, y)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
null(nil)
null(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
minsort(x0)
mins(x0, x1, x2)
if(true, x0, x1, x2)
if(false, x0, x1, x2)
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
null(nil)
null(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
minsort(x0)
mins(x0, x1, x2)
if(true, x0, x1, x2)
if(false, x0, x1, x2)
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
APP(add(n, x), y) → APP(x, y)
From the DPs we obtained the following set of size-change graphs:
LE(s(x), s(y)) → LE(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) → min(add(n, x))
if_min(false, add(n, add(m, x))) → min(add(m, x))
head(add(n, x)) → n
tail(add(n, x)) → x
tail(nil) → nil
null(nil) → true
null(add(n, x)) → false
rm(n, nil) → nil
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) → rm(n, x)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
minsort(x) → mins(x, nil, nil)
mins(x, y, z) → if(null(x), x, y, z)
if(true, x, y, z) → z
if(false, x, y, z) → if2(eq(head(x), min(x)), x, y, z)
if2(true, x, y, z) → mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil)))
if2(false, x, y, z) → mins(tail(x), add(head(x), y), z)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
null(nil)
null(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
minsort(x0)
mins(x0, x1, x2)
if(true, x0, x1, x2)
if(false, x0, x1, x2)
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
LE(s(x), s(y)) → LE(x, y)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
null(nil)
null(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
minsort(x0)
mins(x0, x1, x2)
if(true, x0, x1, x2)
if(false, x0, x1, x2)
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
null(nil)
null(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
minsort(x0)
mins(x0, x1, x2)
if(true, x0, x1, x2)
if(false, x0, x1, x2)
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
LE(s(x), s(y)) → LE(x, y)
From the DPs we obtained the following set of size-change graphs:
MIN(add(n, add(m, x))) → IF_MIN(le(n, m), add(n, add(m, x)))
IF_MIN(true, add(n, add(m, x))) → MIN(add(n, x))
IF_MIN(false, add(n, add(m, x))) → MIN(add(m, x))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) → min(add(n, x))
if_min(false, add(n, add(m, x))) → min(add(m, x))
head(add(n, x)) → n
tail(add(n, x)) → x
tail(nil) → nil
null(nil) → true
null(add(n, x)) → false
rm(n, nil) → nil
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) → rm(n, x)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
minsort(x) → mins(x, nil, nil)
mins(x, y, z) → if(null(x), x, y, z)
if(true, x, y, z) → z
if(false, x, y, z) → if2(eq(head(x), min(x)), x, y, z)
if2(true, x, y, z) → mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil)))
if2(false, x, y, z) → mins(tail(x), add(head(x), y), z)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
null(nil)
null(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
minsort(x0)
mins(x0, x1, x2)
if(true, x0, x1, x2)
if(false, x0, x1, x2)
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
MIN(add(n, add(m, x))) → IF_MIN(le(n, m), add(n, add(m, x)))
IF_MIN(true, add(n, add(m, x))) → MIN(add(n, x))
IF_MIN(false, add(n, add(m, x))) → MIN(add(m, x))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
null(nil)
null(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
minsort(x0)
mins(x0, x1, x2)
if(true, x0, x1, x2)
if(false, x0, x1, x2)
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
null(nil)
null(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
minsort(x0)
mins(x0, x1, x2)
if(true, x0, x1, x2)
if(false, x0, x1, x2)
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
MIN(add(n, add(m, x))) → IF_MIN(le(n, m), add(n, add(m, x)))
IF_MIN(true, add(n, add(m, x))) → MIN(add(n, x))
IF_MIN(false, add(n, add(m, x))) → MIN(add(m, x))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
The following pairs can be oriented strictly and are deleted.
The remaining pairs can at least be oriented weakly.
IF_MIN(true, add(n, add(m, x))) → MIN(add(n, x))
IF_MIN(false, add(n, add(m, x))) → MIN(add(m, x))
POL(0) = 0
POL(IF_MIN(x1, x2)) = 1 + x2
POL(MIN(x1)) = 1 + x1
POL(add(x1, x2)) = 1 + x2
POL(false) = 0
POL(le(x1, x2)) = 0
POL(s(x1)) = 0
POL(true) = 0
MIN(add(n, add(m, x))) → IF_MIN(le(n, m), add(n, add(m, x)))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
EQ(s(x), s(y)) → EQ(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) → min(add(n, x))
if_min(false, add(n, add(m, x))) → min(add(m, x))
head(add(n, x)) → n
tail(add(n, x)) → x
tail(nil) → nil
null(nil) → true
null(add(n, x)) → false
rm(n, nil) → nil
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) → rm(n, x)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
minsort(x) → mins(x, nil, nil)
mins(x, y, z) → if(null(x), x, y, z)
if(true, x, y, z) → z
if(false, x, y, z) → if2(eq(head(x), min(x)), x, y, z)
if2(true, x, y, z) → mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil)))
if2(false, x, y, z) → mins(tail(x), add(head(x), y), z)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
null(nil)
null(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
minsort(x0)
mins(x0, x1, x2)
if(true, x0, x1, x2)
if(false, x0, x1, x2)
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
EQ(s(x), s(y)) → EQ(x, y)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
null(nil)
null(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
minsort(x0)
mins(x0, x1, x2)
if(true, x0, x1, x2)
if(false, x0, x1, x2)
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
null(nil)
null(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
minsort(x0)
mins(x0, x1, x2)
if(true, x0, x1, x2)
if(false, x0, x1, x2)
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
EQ(s(x), s(y)) → EQ(x, y)
From the DPs we obtained the following set of size-change graphs:
RM(n, add(m, x)) → IF_RM(eq(n, m), n, add(m, x))
IF_RM(true, n, add(m, x)) → RM(n, x)
IF_RM(false, n, add(m, x)) → RM(n, x)
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) → min(add(n, x))
if_min(false, add(n, add(m, x))) → min(add(m, x))
head(add(n, x)) → n
tail(add(n, x)) → x
tail(nil) → nil
null(nil) → true
null(add(n, x)) → false
rm(n, nil) → nil
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) → rm(n, x)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
minsort(x) → mins(x, nil, nil)
mins(x, y, z) → if(null(x), x, y, z)
if(true, x, y, z) → z
if(false, x, y, z) → if2(eq(head(x), min(x)), x, y, z)
if2(true, x, y, z) → mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil)))
if2(false, x, y, z) → mins(tail(x), add(head(x), y), z)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
null(nil)
null(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
minsort(x0)
mins(x0, x1, x2)
if(true, x0, x1, x2)
if(false, x0, x1, x2)
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
RM(n, add(m, x)) → IF_RM(eq(n, m), n, add(m, x))
IF_RM(true, n, add(m, x)) → RM(n, x)
IF_RM(false, n, add(m, x)) → RM(n, x)
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
null(nil)
null(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
minsort(x0)
mins(x0, x1, x2)
if(true, x0, x1, x2)
if(false, x0, x1, x2)
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
null(nil)
null(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
minsort(x0)
mins(x0, x1, x2)
if(true, x0, x1, x2)
if(false, x0, x1, x2)
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
RM(n, add(m, x)) → IF_RM(eq(n, m), n, add(m, x))
IF_RM(true, n, add(m, x)) → RM(n, x)
IF_RM(false, n, add(m, x)) → RM(n, x)
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
From the DPs we obtained the following set of size-change graphs:
IF2(true, x, y, z) → MINS(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil)))
MINS(x, y, z) → IF(null(x), x, y, z)
IF(false, x, y, z) → IF2(eq(head(x), min(x)), x, y, z)
IF2(false, x, y, z) → MINS(tail(x), add(head(x), y), z)
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(true, add(n, add(m, x))) → min(add(n, x))
if_min(false, add(n, add(m, x))) → min(add(m, x))
head(add(n, x)) → n
tail(add(n, x)) → x
tail(nil) → nil
null(nil) → true
null(add(n, x)) → false
rm(n, nil) → nil
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
if_rm(true, n, add(m, x)) → rm(n, x)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
minsort(x) → mins(x, nil, nil)
mins(x, y, z) → if(null(x), x, y, z)
if(true, x, y, z) → z
if(false, x, y, z) → if2(eq(head(x), min(x)), x, y, z)
if2(true, x, y, z) → mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil)))
if2(false, x, y, z) → mins(tail(x), add(head(x), y), z)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
null(nil)
null(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
minsort(x0)
mins(x0, x1, x2)
if(true, x0, x1, x2)
if(false, x0, x1, x2)
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
IF2(true, x, y, z) → MINS(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil)))
MINS(x, y, z) → IF(null(x), x, y, z)
IF(false, x, y, z) → IF2(eq(head(x), min(x)), x, y, z)
IF2(false, x, y, z) → MINS(tail(x), add(head(x), y), z)
tail(add(n, x)) → x
tail(nil) → nil
head(add(n, x)) → n
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
null(nil) → true
null(add(n, x)) → false
rm(n, nil) → nil
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
null(nil)
null(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
minsort(x0)
mins(x0, x1, x2)
if(true, x0, x1, x2)
if(false, x0, x1, x2)
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
minsort(x0)
mins(x0, x1, x2)
if(true, x0, x1, x2)
if(false, x0, x1, x2)
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
IF2(true, x, y, z) → MINS(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil)))
MINS(x, y, z) → IF(null(x), x, y, z)
IF(false, x, y, z) → IF2(eq(head(x), min(x)), x, y, z)
IF2(false, x, y, z) → MINS(tail(x), add(head(x), y), z)
tail(add(n, x)) → x
tail(nil) → nil
head(add(n, x)) → n
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
null(nil) → true
null(add(n, x)) → false
rm(n, nil) → nil
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
null(nil)
null(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
MINS(y_3, nil, y_5) → IF(null(y_3), y_3, nil, y_5)
MINS(y_0, add(y_1, z1), z2) → IF(null(y_0), y_0, add(y_1, z1), z2)
IF2(true, x, y, z) → MINS(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil)))
IF(false, x, y, z) → IF2(eq(head(x), min(x)), x, y, z)
IF2(false, x, y, z) → MINS(tail(x), add(head(x), y), z)
MINS(y_3, nil, y_5) → IF(null(y_3), y_3, nil, y_5)
MINS(y_0, add(y_1, z1), z2) → IF(null(y_0), y_0, add(y_1, z1), z2)
tail(add(n, x)) → x
tail(nil) → nil
head(add(n, x)) → n
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
null(nil) → true
null(add(n, x)) → false
rm(n, nil) → nil
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
null(nil)
null(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
MINS(nil, y1, y2) → IF(true, nil, y1, y2)
MINS(add(x0, x1), y1, y2) → IF(false, add(x0, x1), y1, y2)
IF2(true, x, y, z) → MINS(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil)))
IF(false, x, y, z) → IF2(eq(head(x), min(x)), x, y, z)
IF2(false, x, y, z) → MINS(tail(x), add(head(x), y), z)
MINS(nil, y1, y2) → IF(true, nil, y1, y2)
MINS(add(x0, x1), y1, y2) → IF(false, add(x0, x1), y1, y2)
tail(add(n, x)) → x
tail(nil) → nil
head(add(n, x)) → n
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
null(nil) → true
null(add(n, x)) → false
rm(n, nil) → nil
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
null(nil)
null(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
MINS(add(x0, x1), y1, y2) → IF(false, add(x0, x1), y1, y2)
IF(false, x, y, z) → IF2(eq(head(x), min(x)), x, y, z)
IF2(true, x, y, z) → MINS(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil)))
IF2(false, x, y, z) → MINS(tail(x), add(head(x), y), z)
tail(add(n, x)) → x
tail(nil) → nil
head(add(n, x)) → n
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
null(nil) → true
null(add(n, x)) → false
rm(n, nil) → nil
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
null(nil)
null(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
MINS(add(x0, x1), y1, y2) → IF(false, add(x0, x1), y1, y2)
IF(false, x, y, z) → IF2(eq(head(x), min(x)), x, y, z)
IF2(true, x, y, z) → MINS(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil)))
IF2(false, x, y, z) → MINS(tail(x), add(head(x), y), z)
tail(add(n, x)) → x
tail(nil) → nil
head(add(n, x)) → n
rm(n, nil) → nil
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
null(nil)
null(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
null(nil)
null(add(x0, x1))
MINS(add(x0, x1), y1, y2) → IF(false, add(x0, x1), y1, y2)
IF(false, x, y, z) → IF2(eq(head(x), min(x)), x, y, z)
IF2(true, x, y, z) → MINS(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil)))
IF2(false, x, y, z) → MINS(tail(x), add(head(x), y), z)
tail(add(n, x)) → x
tail(nil) → nil
head(add(n, x)) → n
rm(n, nil) → nil
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
IF2(true, add(x0, x1), y1, y2) → MINS(app(rm(x0, tail(add(x0, x1))), y1), nil, app(y2, add(head(add(x0, x1)), nil)))
IF2(true, add(x0, x1), y1, y2) → MINS(app(rm(head(add(x0, x1)), x1), y1), nil, app(y2, add(head(add(x0, x1)), nil)))
IF2(true, nil, y1, y2) → MINS(app(rm(head(nil), nil), y1), nil, app(y2, add(head(nil), nil)))
MINS(add(x0, x1), y1, y2) → IF(false, add(x0, x1), y1, y2)
IF(false, x, y, z) → IF2(eq(head(x), min(x)), x, y, z)
IF2(false, x, y, z) → MINS(tail(x), add(head(x), y), z)
IF2(true, add(x0, x1), y1, y2) → MINS(app(rm(x0, tail(add(x0, x1))), y1), nil, app(y2, add(head(add(x0, x1)), nil)))
IF2(true, add(x0, x1), y1, y2) → MINS(app(rm(head(add(x0, x1)), x1), y1), nil, app(y2, add(head(add(x0, x1)), nil)))
IF2(true, nil, y1, y2) → MINS(app(rm(head(nil), nil), y1), nil, app(y2, add(head(nil), nil)))
tail(add(n, x)) → x
tail(nil) → nil
head(add(n, x)) → n
rm(n, nil) → nil
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
IF2(true, add(x0, x1), y1, y2) → MINS(app(rm(x0, x1), y1), nil, app(y2, add(head(add(x0, x1)), nil)))
MINS(add(x0, x1), y1, y2) → IF(false, add(x0, x1), y1, y2)
IF(false, x, y, z) → IF2(eq(head(x), min(x)), x, y, z)
IF2(false, x, y, z) → MINS(tail(x), add(head(x), y), z)
IF2(true, add(x0, x1), y1, y2) → MINS(app(rm(head(add(x0, x1)), x1), y1), nil, app(y2, add(head(add(x0, x1)), nil)))
IF2(true, nil, y1, y2) → MINS(app(rm(head(nil), nil), y1), nil, app(y2, add(head(nil), nil)))
IF2(true, add(x0, x1), y1, y2) → MINS(app(rm(x0, x1), y1), nil, app(y2, add(head(add(x0, x1)), nil)))
tail(add(n, x)) → x
tail(nil) → nil
head(add(n, x)) → n
rm(n, nil) → nil
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
IF2(true, add(x0, x1), y1, y2) → MINS(app(rm(x0, x1), y1), nil, app(y2, add(head(add(x0, x1)), nil)))
MINS(add(x0, x1), y1, y2) → IF(false, add(x0, x1), y1, y2)
IF(false, x, y, z) → IF2(eq(head(x), min(x)), x, y, z)
IF2(false, x, y, z) → MINS(tail(x), add(head(x), y), z)
IF2(true, nil, y1, y2) → MINS(app(rm(head(nil), nil), y1), nil, app(y2, add(head(nil), nil)))
IF2(true, add(x0, x1), y1, y2) → MINS(app(rm(x0, x1), y1), nil, app(y2, add(head(add(x0, x1)), nil)))
tail(add(n, x)) → x
tail(nil) → nil
head(add(n, x)) → n
rm(n, nil) → nil
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
IF2(true, nil, y1, y2) → MINS(app(nil, y1), nil, app(y2, add(head(nil), nil)))
MINS(add(x0, x1), y1, y2) → IF(false, add(x0, x1), y1, y2)
IF(false, x, y, z) → IF2(eq(head(x), min(x)), x, y, z)
IF2(false, x, y, z) → MINS(tail(x), add(head(x), y), z)
IF2(true, add(x0, x1), y1, y2) → MINS(app(rm(x0, x1), y1), nil, app(y2, add(head(add(x0, x1)), nil)))
IF2(true, nil, y1, y2) → MINS(app(nil, y1), nil, app(y2, add(head(nil), nil)))
tail(add(n, x)) → x
tail(nil) → nil
head(add(n, x)) → n
rm(n, nil) → nil
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
IF2(true, add(x0, x1), y1, y2) → MINS(app(rm(x0, x1), y1), nil, app(y2, add(x0, nil)))
MINS(add(x0, x1), y1, y2) → IF(false, add(x0, x1), y1, y2)
IF(false, x, y, z) → IF2(eq(head(x), min(x)), x, y, z)
IF2(false, x, y, z) → MINS(tail(x), add(head(x), y), z)
IF2(true, nil, y1, y2) → MINS(app(nil, y1), nil, app(y2, add(head(nil), nil)))
IF2(true, add(x0, x1), y1, y2) → MINS(app(rm(x0, x1), y1), nil, app(y2, add(x0, nil)))
tail(add(n, x)) → x
tail(nil) → nil
head(add(n, x)) → n
rm(n, nil) → nil
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
IF2(true, nil, y1, y2) → MINS(y1, nil, app(y2, add(head(nil), nil)))
MINS(add(x0, x1), y1, y2) → IF(false, add(x0, x1), y1, y2)
IF(false, x, y, z) → IF2(eq(head(x), min(x)), x, y, z)
IF2(false, x, y, z) → MINS(tail(x), add(head(x), y), z)
IF2(true, add(x0, x1), y1, y2) → MINS(app(rm(x0, x1), y1), nil, app(y2, add(x0, nil)))
IF2(true, nil, y1, y2) → MINS(y1, nil, app(y2, add(head(nil), nil)))
tail(add(n, x)) → x
tail(nil) → nil
head(add(n, x)) → n
rm(n, nil) → nil
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
IF2(false, add(x0, x1), y1, y2) → MINS(x1, add(head(add(x0, x1)), y1), y2)
IF2(false, nil, y1, y2) → MINS(nil, add(head(nil), y1), y2)
MINS(add(x0, x1), y1, y2) → IF(false, add(x0, x1), y1, y2)
IF(false, x, y, z) → IF2(eq(head(x), min(x)), x, y, z)
IF2(true, add(x0, x1), y1, y2) → MINS(app(rm(x0, x1), y1), nil, app(y2, add(x0, nil)))
IF2(true, nil, y1, y2) → MINS(y1, nil, app(y2, add(head(nil), nil)))
IF2(false, add(x0, x1), y1, y2) → MINS(x1, add(head(add(x0, x1)), y1), y2)
IF2(false, nil, y1, y2) → MINS(nil, add(head(nil), y1), y2)
tail(add(n, x)) → x
tail(nil) → nil
head(add(n, x)) → n
rm(n, nil) → nil
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
IF(false, x, y, z) → IF2(eq(head(x), min(x)), x, y, z)
IF2(true, add(x0, x1), y1, y2) → MINS(app(rm(x0, x1), y1), nil, app(y2, add(x0, nil)))
MINS(add(x0, x1), y1, y2) → IF(false, add(x0, x1), y1, y2)
IF2(true, nil, y1, y2) → MINS(y1, nil, app(y2, add(head(nil), nil)))
IF2(false, add(x0, x1), y1, y2) → MINS(x1, add(head(add(x0, x1)), y1), y2)
tail(add(n, x)) → x
tail(nil) → nil
head(add(n, x)) → n
rm(n, nil) → nil
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
IF(false, x, y, z) → IF2(eq(head(x), min(x)), x, y, z)
IF2(true, add(x0, x1), y1, y2) → MINS(app(rm(x0, x1), y1), nil, app(y2, add(x0, nil)))
MINS(add(x0, x1), y1, y2) → IF(false, add(x0, x1), y1, y2)
IF2(true, nil, y1, y2) → MINS(y1, nil, app(y2, add(head(nil), nil)))
IF2(false, add(x0, x1), y1, y2) → MINS(x1, add(head(add(x0, x1)), y1), y2)
head(add(n, x)) → n
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
rm(n, nil) → nil
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
tail(add(x0, x1))
tail(nil)
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
tail(add(x0, x1))
tail(nil)
IF(false, x, y, z) → IF2(eq(head(x), min(x)), x, y, z)
IF2(true, add(x0, x1), y1, y2) → MINS(app(rm(x0, x1), y1), nil, app(y2, add(x0, nil)))
MINS(add(x0, x1), y1, y2) → IF(false, add(x0, x1), y1, y2)
IF2(true, nil, y1, y2) → MINS(y1, nil, app(y2, add(head(nil), nil)))
IF2(false, add(x0, x1), y1, y2) → MINS(x1, add(head(add(x0, x1)), y1), y2)
head(add(n, x)) → n
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
rm(n, nil) → nil
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
IF2(false, add(x0, x1), y1, y2) → MINS(x1, add(x0, y1), y2)
IF(false, x, y, z) → IF2(eq(head(x), min(x)), x, y, z)
IF2(true, add(x0, x1), y1, y2) → MINS(app(rm(x0, x1), y1), nil, app(y2, add(x0, nil)))
MINS(add(x0, x1), y1, y2) → IF(false, add(x0, x1), y1, y2)
IF2(true, nil, y1, y2) → MINS(y1, nil, app(y2, add(head(nil), nil)))
IF2(false, add(x0, x1), y1, y2) → MINS(x1, add(x0, y1), y2)
head(add(n, x)) → n
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
rm(n, nil) → nil
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
IF(false, add(z0, z1), z2, z3) → IF2(eq(head(add(z0, z1)), min(add(z0, z1))), add(z0, z1), z2, z3)
IF2(true, add(x0, x1), y1, y2) → MINS(app(rm(x0, x1), y1), nil, app(y2, add(x0, nil)))
MINS(add(x0, x1), y1, y2) → IF(false, add(x0, x1), y1, y2)
IF2(true, nil, y1, y2) → MINS(y1, nil, app(y2, add(head(nil), nil)))
IF2(false, add(x0, x1), y1, y2) → MINS(x1, add(x0, y1), y2)
IF(false, add(z0, z1), z2, z3) → IF2(eq(head(add(z0, z1)), min(add(z0, z1))), add(z0, z1), z2, z3)
head(add(n, x)) → n
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
rm(n, nil) → nil
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
MINS(add(x0, x1), y1, y2) → IF(false, add(x0, x1), y1, y2)
IF(false, add(z0, z1), z2, z3) → IF2(eq(head(add(z0, z1)), min(add(z0, z1))), add(z0, z1), z2, z3)
IF2(true, add(x0, x1), y1, y2) → MINS(app(rm(x0, x1), y1), nil, app(y2, add(x0, nil)))
IF2(false, add(x0, x1), y1, y2) → MINS(x1, add(x0, y1), y2)
head(add(n, x)) → n
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
rm(n, nil) → nil
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
IF(false, add(z0, z1), z2, z3) → IF2(eq(z0, min(add(z0, z1))), add(z0, z1), z2, z3)
MINS(add(x0, x1), y1, y2) → IF(false, add(x0, x1), y1, y2)
IF2(true, add(x0, x1), y1, y2) → MINS(app(rm(x0, x1), y1), nil, app(y2, add(x0, nil)))
IF2(false, add(x0, x1), y1, y2) → MINS(x1, add(x0, y1), y2)
IF(false, add(z0, z1), z2, z3) → IF2(eq(z0, min(add(z0, z1))), add(z0, z1), z2, z3)
head(add(n, x)) → n
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
rm(n, nil) → nil
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
MINS(add(x0, x1), y1, y2) → IF(false, add(x0, x1), y1, y2)
IF2(true, add(x0, x1), y1, y2) → MINS(app(rm(x0, x1), y1), nil, app(y2, add(x0, nil)))
IF2(false, add(x0, x1), y1, y2) → MINS(x1, add(x0, y1), y2)
IF(false, add(z0, z1), z2, z3) → IF2(eq(z0, min(add(z0, z1))), add(z0, z1), z2, z3)
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
rm(n, nil) → nil
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
head(add(x0, x1))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
head(add(x0, x1))
MINS(add(x0, x1), y1, y2) → IF(false, add(x0, x1), y1, y2)
IF2(true, add(x0, x1), y1, y2) → MINS(app(rm(x0, x1), y1), nil, app(y2, add(x0, nil)))
IF2(false, add(x0, x1), y1, y2) → MINS(x1, add(x0, y1), y2)
IF(false, add(z0, z1), z2, z3) → IF2(eq(z0, min(add(z0, z1))), add(z0, z1), z2, z3)
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
rm(n, nil) → nil
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
The following pairs can be oriented strictly and are deleted.
The remaining pairs can at least be oriented weakly.
IF2(true, add(x0, x1), y1, y2) → MINS(app(rm(x0, x1), y1), nil, app(y2, add(x0, nil)))
POL(0) = 0
POL(IF(x1, x2, x3, x4)) = x2 + x3
POL(IF2(x1, x2, x3, x4)) = x2 + x3
POL(MINS(x1, x2, x3)) = x1 + x2
POL(add(x1, x2)) = 1 + x2
POL(app(x1, x2)) = x1 + x2
POL(eq(x1, x2)) = 0
POL(false) = 0
POL(if_min(x1, x2)) = 0
POL(if_rm(x1, x2, x3)) = x3
POL(le(x1, x2)) = 0
POL(min(x1)) = 0
POL(nil) = 0
POL(rm(x1, x2)) = x2
POL(s(x1)) = 0
POL(true) = 0
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
app(add(n, x), y) → add(n, app(x, y))
app(nil, y) → y
rm(n, nil) → nil
MINS(add(x0, x1), y1, y2) → IF(false, add(x0, x1), y1, y2)
IF2(false, add(x0, x1), y1, y2) → MINS(x1, add(x0, y1), y2)
IF(false, add(z0, z1), z2, z3) → IF2(eq(z0, min(add(z0, z1))), add(z0, z1), z2, z3)
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
rm(n, nil) → nil
if_rm(true, n, add(m, x)) → rm(n, x)
rm(n, add(m, x)) → if_rm(eq(n, m), n, add(m, x))
app(nil, y) → y
app(add(n, x), y) → add(n, app(x, y))
if_rm(false, n, add(m, x)) → add(m, rm(n, x))
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
MINS(add(x0, x1), y1, y2) → IF(false, add(x0, x1), y1, y2)
IF2(false, add(x0, x1), y1, y2) → MINS(x1, add(x0, y1), y2)
IF(false, add(z0, z1), z2, z3) → IF2(eq(z0, min(add(z0, z1))), add(z0, z1), z2, z3)
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
app(nil, x0)
app(add(x0, x1), x2)
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
app(nil, x0)
app(add(x0, x1), x2)
rm(x0, nil)
rm(x0, add(x1, x2))
if_rm(true, x0, add(x1, x2))
if_rm(false, x0, add(x1, x2))
MINS(add(x0, x1), y1, y2) → IF(false, add(x0, x1), y1, y2)
IF2(false, add(x0, x1), y1, y2) → MINS(x1, add(x0, y1), y2)
IF(false, add(z0, z1), z2, z3) → IF2(eq(z0, min(add(z0, z1))), add(z0, z1), z2, z3)
min(add(n, nil)) → n
min(add(n, add(m, x))) → if_min(le(n, m), add(n, add(m, x)))
if_min(false, add(n, add(m, x))) → min(add(m, x))
if_min(true, add(n, add(m, x))) → min(add(n, x))
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
min(add(x0, nil))
min(add(x0, add(x1, x2)))
if_min(true, add(x0, add(x1, x2)))
if_min(false, add(x0, add(x1, x2)))
From the DPs we obtained the following set of size-change graphs: