(0) Obligation:
Q restricted rewrite system:
The TRS R consists of the following rules:
eq(0, 0) → true
eq(0, s(y)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
lt(0, s(y)) → true
lt(x, 0) → false
lt(s(x), s(y)) → lt(x, y)
bin2s(nil) → 0
bin2s(cons(x, xs)) → bin2ss(x, xs)
bin2ss(x, nil) → x
bin2ss(x, cons(0, xs)) → bin2ss(double(x), xs)
bin2ss(x, cons(1, xs)) → bin2ss(s(double(x)), xs)
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
log(0) → 0
log(s(0)) → 0
log(s(s(x))) → s(log(half(s(s(x)))))
more(nil) → nil
more(cons(xs, ys)) → cons(cons(0, xs), cons(cons(1, xs), cons(xs, ys)))
s2bin(x) → s2bin1(x, 0, cons(nil, nil))
s2bin1(x, y, lists) → if1(lt(y, log(x)), x, y, lists)
if1(true, x, y, lists) → s2bin1(x, s(y), more(lists))
if1(false, x, y, lists) → s2bin2(x, lists)
s2bin2(x, nil) → bug_list_not
s2bin2(x, cons(xs, ys)) → if2(eq(x, bin2s(xs)), x, xs, ys)
if2(true, x, xs, ys) → xs
if2(false, x, xs, ys) → s2bin2(x, ys)
Q is empty.
(1) Overlay + Local Confluence (EQUIVALENT transformation)
The TRS is overlay and locally confluent. By [NOC] we can switch to innermost.
(2) Obligation:
Q restricted rewrite system:
The TRS R consists of the following rules:
eq(0, 0) → true
eq(0, s(y)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
lt(0, s(y)) → true
lt(x, 0) → false
lt(s(x), s(y)) → lt(x, y)
bin2s(nil) → 0
bin2s(cons(x, xs)) → bin2ss(x, xs)
bin2ss(x, nil) → x
bin2ss(x, cons(0, xs)) → bin2ss(double(x), xs)
bin2ss(x, cons(1, xs)) → bin2ss(s(double(x)), xs)
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
log(0) → 0
log(s(0)) → 0
log(s(s(x))) → s(log(half(s(s(x)))))
more(nil) → nil
more(cons(xs, ys)) → cons(cons(0, xs), cons(cons(1, xs), cons(xs, ys)))
s2bin(x) → s2bin1(x, 0, cons(nil, nil))
s2bin1(x, y, lists) → if1(lt(y, log(x)), x, y, lists)
if1(true, x, y, lists) → s2bin1(x, s(y), more(lists))
if1(false, x, y, lists) → s2bin2(x, lists)
s2bin2(x, nil) → bug_list_not
s2bin2(x, cons(xs, ys)) → if2(eq(x, bin2s(xs)), x, xs, ys)
if2(true, x, xs, ys) → xs
if2(false, x, xs, ys) → s2bin2(x, ys)
The set Q consists of the following terms:
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
lt(0, s(x0))
lt(x0, 0)
lt(s(x0), s(x1))
bin2s(nil)
bin2s(cons(x0, x1))
bin2ss(x0, nil)
bin2ss(x0, cons(0, x1))
bin2ss(x0, cons(1, x1))
half(0)
half(s(0))
half(s(s(x0)))
log(0)
log(s(0))
log(s(s(x0)))
more(nil)
more(cons(x0, x1))
s2bin(x0)
s2bin1(x0, x1, x2)
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
s2bin2(x0, nil)
s2bin2(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
(3) DependencyPairsProof (EQUIVALENT transformation)
Using Dependency Pairs [AG00,LPAR04] we result in the following initial DP problem.
(4) Obligation:
Q DP problem:
The TRS P consists of the following rules:
EQ(s(x), s(y)) → EQ(x, y)
LT(s(x), s(y)) → LT(x, y)
BIN2S(cons(x, xs)) → BIN2SS(x, xs)
BIN2SS(x, cons(0, xs)) → BIN2SS(double(x), xs)
BIN2SS(x, cons(1, xs)) → BIN2SS(s(double(x)), xs)
HALF(s(s(x))) → HALF(x)
LOG(s(s(x))) → LOG(half(s(s(x))))
LOG(s(s(x))) → HALF(s(s(x)))
S2BIN(x) → S2BIN1(x, 0, cons(nil, nil))
S2BIN1(x, y, lists) → IF1(lt(y, log(x)), x, y, lists)
S2BIN1(x, y, lists) → LT(y, log(x))
S2BIN1(x, y, lists) → LOG(x)
IF1(true, x, y, lists) → S2BIN1(x, s(y), more(lists))
IF1(true, x, y, lists) → MORE(lists)
IF1(false, x, y, lists) → S2BIN2(x, lists)
S2BIN2(x, cons(xs, ys)) → IF2(eq(x, bin2s(xs)), x, xs, ys)
S2BIN2(x, cons(xs, ys)) → EQ(x, bin2s(xs))
S2BIN2(x, cons(xs, ys)) → BIN2S(xs)
IF2(false, x, xs, ys) → S2BIN2(x, ys)
The TRS R consists of the following rules:
eq(0, 0) → true
eq(0, s(y)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
lt(0, s(y)) → true
lt(x, 0) → false
lt(s(x), s(y)) → lt(x, y)
bin2s(nil) → 0
bin2s(cons(x, xs)) → bin2ss(x, xs)
bin2ss(x, nil) → x
bin2ss(x, cons(0, xs)) → bin2ss(double(x), xs)
bin2ss(x, cons(1, xs)) → bin2ss(s(double(x)), xs)
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
log(0) → 0
log(s(0)) → 0
log(s(s(x))) → s(log(half(s(s(x)))))
more(nil) → nil
more(cons(xs, ys)) → cons(cons(0, xs), cons(cons(1, xs), cons(xs, ys)))
s2bin(x) → s2bin1(x, 0, cons(nil, nil))
s2bin1(x, y, lists) → if1(lt(y, log(x)), x, y, lists)
if1(true, x, y, lists) → s2bin1(x, s(y), more(lists))
if1(false, x, y, lists) → s2bin2(x, lists)
s2bin2(x, nil) → bug_list_not
s2bin2(x, cons(xs, ys)) → if2(eq(x, bin2s(xs)), x, xs, ys)
if2(true, x, xs, ys) → xs
if2(false, x, xs, ys) → s2bin2(x, ys)
The set Q consists of the following terms:
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
lt(0, s(x0))
lt(x0, 0)
lt(s(x0), s(x1))
bin2s(nil)
bin2s(cons(x0, x1))
bin2ss(x0, nil)
bin2ss(x0, cons(0, x1))
bin2ss(x0, cons(1, x1))
half(0)
half(s(0))
half(s(s(x0)))
log(0)
log(s(0))
log(s(s(x0)))
more(nil)
more(cons(x0, x1))
s2bin(x0)
s2bin1(x0, x1, x2)
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
s2bin2(x0, nil)
s2bin2(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
We have to consider all minimal (P,Q,R)-chains.
(5) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 7 SCCs with 9 less nodes.
(6) Complex Obligation (AND)
(7) Obligation:
Q DP problem:
The TRS P consists of the following rules:
HALF(s(s(x))) → HALF(x)
The TRS R consists of the following rules:
eq(0, 0) → true
eq(0, s(y)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
lt(0, s(y)) → true
lt(x, 0) → false
lt(s(x), s(y)) → lt(x, y)
bin2s(nil) → 0
bin2s(cons(x, xs)) → bin2ss(x, xs)
bin2ss(x, nil) → x
bin2ss(x, cons(0, xs)) → bin2ss(double(x), xs)
bin2ss(x, cons(1, xs)) → bin2ss(s(double(x)), xs)
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
log(0) → 0
log(s(0)) → 0
log(s(s(x))) → s(log(half(s(s(x)))))
more(nil) → nil
more(cons(xs, ys)) → cons(cons(0, xs), cons(cons(1, xs), cons(xs, ys)))
s2bin(x) → s2bin1(x, 0, cons(nil, nil))
s2bin1(x, y, lists) → if1(lt(y, log(x)), x, y, lists)
if1(true, x, y, lists) → s2bin1(x, s(y), more(lists))
if1(false, x, y, lists) → s2bin2(x, lists)
s2bin2(x, nil) → bug_list_not
s2bin2(x, cons(xs, ys)) → if2(eq(x, bin2s(xs)), x, xs, ys)
if2(true, x, xs, ys) → xs
if2(false, x, xs, ys) → s2bin2(x, ys)
The set Q consists of the following terms:
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
lt(0, s(x0))
lt(x0, 0)
lt(s(x0), s(x1))
bin2s(nil)
bin2s(cons(x0, x1))
bin2ss(x0, nil)
bin2ss(x0, cons(0, x1))
bin2ss(x0, cons(1, x1))
half(0)
half(s(0))
half(s(s(x0)))
log(0)
log(s(0))
log(s(s(x0)))
more(nil)
more(cons(x0, x1))
s2bin(x0)
s2bin1(x0, x1, x2)
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
s2bin2(x0, nil)
s2bin2(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
We have to consider all minimal (P,Q,R)-chains.
(8) Obligation:
Q DP problem:
The TRS P consists of the following rules:
LOG(s(s(x))) → LOG(half(s(s(x))))
The TRS R consists of the following rules:
eq(0, 0) → true
eq(0, s(y)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
lt(0, s(y)) → true
lt(x, 0) → false
lt(s(x), s(y)) → lt(x, y)
bin2s(nil) → 0
bin2s(cons(x, xs)) → bin2ss(x, xs)
bin2ss(x, nil) → x
bin2ss(x, cons(0, xs)) → bin2ss(double(x), xs)
bin2ss(x, cons(1, xs)) → bin2ss(s(double(x)), xs)
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
log(0) → 0
log(s(0)) → 0
log(s(s(x))) → s(log(half(s(s(x)))))
more(nil) → nil
more(cons(xs, ys)) → cons(cons(0, xs), cons(cons(1, xs), cons(xs, ys)))
s2bin(x) → s2bin1(x, 0, cons(nil, nil))
s2bin1(x, y, lists) → if1(lt(y, log(x)), x, y, lists)
if1(true, x, y, lists) → s2bin1(x, s(y), more(lists))
if1(false, x, y, lists) → s2bin2(x, lists)
s2bin2(x, nil) → bug_list_not
s2bin2(x, cons(xs, ys)) → if2(eq(x, bin2s(xs)), x, xs, ys)
if2(true, x, xs, ys) → xs
if2(false, x, xs, ys) → s2bin2(x, ys)
The set Q consists of the following terms:
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
lt(0, s(x0))
lt(x0, 0)
lt(s(x0), s(x1))
bin2s(nil)
bin2s(cons(x0, x1))
bin2ss(x0, nil)
bin2ss(x0, cons(0, x1))
bin2ss(x0, cons(1, x1))
half(0)
half(s(0))
half(s(s(x0)))
log(0)
log(s(0))
log(s(s(x0)))
more(nil)
more(cons(x0, x1))
s2bin(x0)
s2bin1(x0, x1, x2)
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
s2bin2(x0, nil)
s2bin2(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
We have to consider all minimal (P,Q,R)-chains.
(9) Obligation:
Q DP problem:
The TRS P consists of the following rules:
BIN2SS(x, cons(1, xs)) → BIN2SS(s(double(x)), xs)
BIN2SS(x, cons(0, xs)) → BIN2SS(double(x), xs)
The TRS R consists of the following rules:
eq(0, 0) → true
eq(0, s(y)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
lt(0, s(y)) → true
lt(x, 0) → false
lt(s(x), s(y)) → lt(x, y)
bin2s(nil) → 0
bin2s(cons(x, xs)) → bin2ss(x, xs)
bin2ss(x, nil) → x
bin2ss(x, cons(0, xs)) → bin2ss(double(x), xs)
bin2ss(x, cons(1, xs)) → bin2ss(s(double(x)), xs)
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
log(0) → 0
log(s(0)) → 0
log(s(s(x))) → s(log(half(s(s(x)))))
more(nil) → nil
more(cons(xs, ys)) → cons(cons(0, xs), cons(cons(1, xs), cons(xs, ys)))
s2bin(x) → s2bin1(x, 0, cons(nil, nil))
s2bin1(x, y, lists) → if1(lt(y, log(x)), x, y, lists)
if1(true, x, y, lists) → s2bin1(x, s(y), more(lists))
if1(false, x, y, lists) → s2bin2(x, lists)
s2bin2(x, nil) → bug_list_not
s2bin2(x, cons(xs, ys)) → if2(eq(x, bin2s(xs)), x, xs, ys)
if2(true, x, xs, ys) → xs
if2(false, x, xs, ys) → s2bin2(x, ys)
The set Q consists of the following terms:
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
lt(0, s(x0))
lt(x0, 0)
lt(s(x0), s(x1))
bin2s(nil)
bin2s(cons(x0, x1))
bin2ss(x0, nil)
bin2ss(x0, cons(0, x1))
bin2ss(x0, cons(1, x1))
half(0)
half(s(0))
half(s(s(x0)))
log(0)
log(s(0))
log(s(s(x0)))
more(nil)
more(cons(x0, x1))
s2bin(x0)
s2bin1(x0, x1, x2)
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
s2bin2(x0, nil)
s2bin2(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
We have to consider all minimal (P,Q,R)-chains.
(10) Obligation:
Q DP problem:
The TRS P consists of the following rules:
LT(s(x), s(y)) → LT(x, y)
The TRS R consists of the following rules:
eq(0, 0) → true
eq(0, s(y)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
lt(0, s(y)) → true
lt(x, 0) → false
lt(s(x), s(y)) → lt(x, y)
bin2s(nil) → 0
bin2s(cons(x, xs)) → bin2ss(x, xs)
bin2ss(x, nil) → x
bin2ss(x, cons(0, xs)) → bin2ss(double(x), xs)
bin2ss(x, cons(1, xs)) → bin2ss(s(double(x)), xs)
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
log(0) → 0
log(s(0)) → 0
log(s(s(x))) → s(log(half(s(s(x)))))
more(nil) → nil
more(cons(xs, ys)) → cons(cons(0, xs), cons(cons(1, xs), cons(xs, ys)))
s2bin(x) → s2bin1(x, 0, cons(nil, nil))
s2bin1(x, y, lists) → if1(lt(y, log(x)), x, y, lists)
if1(true, x, y, lists) → s2bin1(x, s(y), more(lists))
if1(false, x, y, lists) → s2bin2(x, lists)
s2bin2(x, nil) → bug_list_not
s2bin2(x, cons(xs, ys)) → if2(eq(x, bin2s(xs)), x, xs, ys)
if2(true, x, xs, ys) → xs
if2(false, x, xs, ys) → s2bin2(x, ys)
The set Q consists of the following terms:
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
lt(0, s(x0))
lt(x0, 0)
lt(s(x0), s(x1))
bin2s(nil)
bin2s(cons(x0, x1))
bin2ss(x0, nil)
bin2ss(x0, cons(0, x1))
bin2ss(x0, cons(1, x1))
half(0)
half(s(0))
half(s(s(x0)))
log(0)
log(s(0))
log(s(s(x0)))
more(nil)
more(cons(x0, x1))
s2bin(x0)
s2bin1(x0, x1, x2)
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
s2bin2(x0, nil)
s2bin2(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
We have to consider all minimal (P,Q,R)-chains.
(11) Obligation:
Q DP problem:
The TRS P consists of the following rules:
EQ(s(x), s(y)) → EQ(x, y)
The TRS R consists of the following rules:
eq(0, 0) → true
eq(0, s(y)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
lt(0, s(y)) → true
lt(x, 0) → false
lt(s(x), s(y)) → lt(x, y)
bin2s(nil) → 0
bin2s(cons(x, xs)) → bin2ss(x, xs)
bin2ss(x, nil) → x
bin2ss(x, cons(0, xs)) → bin2ss(double(x), xs)
bin2ss(x, cons(1, xs)) → bin2ss(s(double(x)), xs)
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
log(0) → 0
log(s(0)) → 0
log(s(s(x))) → s(log(half(s(s(x)))))
more(nil) → nil
more(cons(xs, ys)) → cons(cons(0, xs), cons(cons(1, xs), cons(xs, ys)))
s2bin(x) → s2bin1(x, 0, cons(nil, nil))
s2bin1(x, y, lists) → if1(lt(y, log(x)), x, y, lists)
if1(true, x, y, lists) → s2bin1(x, s(y), more(lists))
if1(false, x, y, lists) → s2bin2(x, lists)
s2bin2(x, nil) → bug_list_not
s2bin2(x, cons(xs, ys)) → if2(eq(x, bin2s(xs)), x, xs, ys)
if2(true, x, xs, ys) → xs
if2(false, x, xs, ys) → s2bin2(x, ys)
The set Q consists of the following terms:
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
lt(0, s(x0))
lt(x0, 0)
lt(s(x0), s(x1))
bin2s(nil)
bin2s(cons(x0, x1))
bin2ss(x0, nil)
bin2ss(x0, cons(0, x1))
bin2ss(x0, cons(1, x1))
half(0)
half(s(0))
half(s(s(x0)))
log(0)
log(s(0))
log(s(s(x0)))
more(nil)
more(cons(x0, x1))
s2bin(x0)
s2bin1(x0, x1, x2)
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
s2bin2(x0, nil)
s2bin2(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
We have to consider all minimal (P,Q,R)-chains.
(12) Obligation:
Q DP problem:
The TRS P consists of the following rules:
S2BIN2(x, cons(xs, ys)) → IF2(eq(x, bin2s(xs)), x, xs, ys)
IF2(false, x, xs, ys) → S2BIN2(x, ys)
The TRS R consists of the following rules:
eq(0, 0) → true
eq(0, s(y)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
lt(0, s(y)) → true
lt(x, 0) → false
lt(s(x), s(y)) → lt(x, y)
bin2s(nil) → 0
bin2s(cons(x, xs)) → bin2ss(x, xs)
bin2ss(x, nil) → x
bin2ss(x, cons(0, xs)) → bin2ss(double(x), xs)
bin2ss(x, cons(1, xs)) → bin2ss(s(double(x)), xs)
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
log(0) → 0
log(s(0)) → 0
log(s(s(x))) → s(log(half(s(s(x)))))
more(nil) → nil
more(cons(xs, ys)) → cons(cons(0, xs), cons(cons(1, xs), cons(xs, ys)))
s2bin(x) → s2bin1(x, 0, cons(nil, nil))
s2bin1(x, y, lists) → if1(lt(y, log(x)), x, y, lists)
if1(true, x, y, lists) → s2bin1(x, s(y), more(lists))
if1(false, x, y, lists) → s2bin2(x, lists)
s2bin2(x, nil) → bug_list_not
s2bin2(x, cons(xs, ys)) → if2(eq(x, bin2s(xs)), x, xs, ys)
if2(true, x, xs, ys) → xs
if2(false, x, xs, ys) → s2bin2(x, ys)
The set Q consists of the following terms:
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
lt(0, s(x0))
lt(x0, 0)
lt(s(x0), s(x1))
bin2s(nil)
bin2s(cons(x0, x1))
bin2ss(x0, nil)
bin2ss(x0, cons(0, x1))
bin2ss(x0, cons(1, x1))
half(0)
half(s(0))
half(s(s(x0)))
log(0)
log(s(0))
log(s(s(x0)))
more(nil)
more(cons(x0, x1))
s2bin(x0)
s2bin1(x0, x1, x2)
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
s2bin2(x0, nil)
s2bin2(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
We have to consider all minimal (P,Q,R)-chains.
(13) Obligation:
Q DP problem:
The TRS P consists of the following rules:
IF1(true, x, y, lists) → S2BIN1(x, s(y), more(lists))
S2BIN1(x, y, lists) → IF1(lt(y, log(x)), x, y, lists)
The TRS R consists of the following rules:
eq(0, 0) → true
eq(0, s(y)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
lt(0, s(y)) → true
lt(x, 0) → false
lt(s(x), s(y)) → lt(x, y)
bin2s(nil) → 0
bin2s(cons(x, xs)) → bin2ss(x, xs)
bin2ss(x, nil) → x
bin2ss(x, cons(0, xs)) → bin2ss(double(x), xs)
bin2ss(x, cons(1, xs)) → bin2ss(s(double(x)), xs)
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
log(0) → 0
log(s(0)) → 0
log(s(s(x))) → s(log(half(s(s(x)))))
more(nil) → nil
more(cons(xs, ys)) → cons(cons(0, xs), cons(cons(1, xs), cons(xs, ys)))
s2bin(x) → s2bin1(x, 0, cons(nil, nil))
s2bin1(x, y, lists) → if1(lt(y, log(x)), x, y, lists)
if1(true, x, y, lists) → s2bin1(x, s(y), more(lists))
if1(false, x, y, lists) → s2bin2(x, lists)
s2bin2(x, nil) → bug_list_not
s2bin2(x, cons(xs, ys)) → if2(eq(x, bin2s(xs)), x, xs, ys)
if2(true, x, xs, ys) → xs
if2(false, x, xs, ys) → s2bin2(x, ys)
The set Q consists of the following terms:
eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
lt(0, s(x0))
lt(x0, 0)
lt(s(x0), s(x1))
bin2s(nil)
bin2s(cons(x0, x1))
bin2ss(x0, nil)
bin2ss(x0, cons(0, x1))
bin2ss(x0, cons(1, x1))
half(0)
half(s(0))
half(s(s(x0)))
log(0)
log(s(0))
log(s(s(x0)))
more(nil)
more(cons(x0, x1))
s2bin(x0)
s2bin1(x0, x1, x2)
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
s2bin2(x0, nil)
s2bin2(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
We have to consider all minimal (P,Q,R)-chains.