/export/starexec/sandbox2/solver/bin/starexec_run_ttt2 /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/output/output_files -------------------------------------------------------------------------------- YES Problem: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Proof: DP Processor: DPs: SUC#(NUMERAL(n)) -> SUC#(n) SUC#(NUMERAL(n)) -> NUMERAL#(SUC(n)) SUC#(BIT1(n)) -> SUC#(n) SUC#(BIT1(n)) -> BIT0#(SUC(n)) PRE#(NUMERAL(n)) -> PRE#(n) PRE#(NUMERAL(n)) -> NUMERAL#(PRE(n)) PRE#(BIT0(n)) -> PRE#(n) PRE#(BIT0(n)) -> eq#(n,0()) PRE#(BIT1(n)) -> BIT0#(n) plus#(NUMERAL(m),NUMERAL(n)) -> plus#(m,n) plus#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(plus(m,n)) plus#(BIT0(m),BIT0(n)) -> plus#(m,n) plus#(BIT0(m),BIT0(n)) -> BIT0#(plus(m,n)) plus#(BIT0(m),BIT1(n)) -> plus#(m,n) plus#(BIT1(m),BIT0(n)) -> plus#(m,n) plus#(BIT1(m),BIT1(n)) -> plus#(m,n) plus#(BIT1(m),BIT1(n)) -> SUC#(plus(m,n)) plus#(BIT1(m),BIT1(n)) -> BIT0#(SUC(plus(m,n))) mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) mult#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(mult(m,n)) mult#(BIT0(m),BIT0(n)) -> mult#(m,n) mult#(BIT0(m),BIT0(n)) -> BIT0#(mult(m,n)) mult#(BIT0(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) mult#(BIT0(m),BIT1(n)) -> mult#(m,n) mult#(BIT0(m),BIT1(n)) -> BIT0#(mult(m,n)) mult#(BIT0(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) mult#(BIT0(m),BIT1(n)) -> plus#(BIT0(m),BIT0(BIT0(mult(m,n)))) mult#(BIT1(m),BIT0(n)) -> mult#(m,n) mult#(BIT1(m),BIT0(n)) -> BIT0#(mult(m,n)) mult#(BIT1(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) mult#(BIT1(m),BIT0(n)) -> plus#(BIT0(n),BIT0(BIT0(mult(m,n)))) mult#(BIT1(m),BIT1(n)) -> mult#(m,n) mult#(BIT1(m),BIT1(n)) -> BIT0#(mult(m,n)) mult#(BIT1(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) mult#(BIT1(m),BIT1(n)) -> BIT0#(n) mult#(BIT1(m),BIT1(n)) -> plus#(BIT1(m),BIT0(n)) mult#(BIT1(m),BIT1(n)) -> plus#(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp#(NUMERAL(m),NUMERAL(n)) -> exp#(m,n) exp#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(exp(m,n)) exp#(0(),BIT0(n)) -> exp#(0(),n) exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) exp#(BIT0(m),BIT0(n)) -> exp#(BIT0(m),n) exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) exp#(BIT1(m),BIT0(n)) -> exp#(BIT1(m),n) exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) exp#(BIT0(m),BIT1(n)) -> exp#(BIT0(m),n) exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp#(BIT1(m),BIT1(n)) -> exp#(BIT1(m),n) exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN#(NUMERAL(n)) -> EVEN#(n) ODD#(NUMERAL(n)) -> ODD#(n) eq#(NUMERAL(m),NUMERAL(n)) -> eq#(m,n) eq#(BIT0(n),0()) -> eq#(n,0()) eq#(0(),BIT0(n)) -> eq#(0(),n) eq#(BIT0(m),BIT0(n)) -> eq#(m,n) eq#(BIT1(m),BIT1(n)) -> eq#(m,n) le#(NUMERAL(m),NUMERAL(n)) -> le#(m,n) le#(BIT0(n),0()) -> le#(n,0()) le#(BIT0(m),BIT0(n)) -> le#(m,n) le#(BIT0(m),BIT1(n)) -> le#(m,n) le#(BIT1(m),BIT0(n)) -> lt#(m,n) le#(BIT1(m),BIT1(n)) -> le#(m,n) lt#(NUMERAL(m),NUMERAL(n)) -> lt#(m,n) lt#(0(),BIT0(n)) -> lt#(0(),n) lt#(BIT0(m),BIT0(n)) -> lt#(m,n) lt#(BIT0(m),BIT1(n)) -> le#(m,n) lt#(BIT1(m),BIT0(n)) -> lt#(m,n) lt#(BIT1(m),BIT1(n)) -> lt#(m,n) ge#(NUMERAL(n),NUMERAL(m)) -> ge#(n,m) ge#(0(),BIT0(n)) -> ge#(0(),n) ge#(BIT0(n),BIT0(m)) -> ge#(n,m) ge#(BIT1(n),BIT0(m)) -> ge#(n,m) ge#(BIT0(n),BIT1(m)) -> gt#(n,m) ge#(BIT1(n),BIT1(m)) -> ge#(n,m) gt#(NUMERAL(n),NUMERAL(m)) -> gt#(n,m) gt#(BIT0(n),0()) -> gt#(n,0()) gt#(BIT0(n),BIT0(m)) -> gt#(n,m) gt#(BIT1(n),BIT0(m)) -> ge#(n,m) gt#(BIT0(n),BIT1(m)) -> gt#(n,m) gt#(BIT1(n),BIT1(m)) -> gt#(n,m) minus#(NUMERAL(m),NUMERAL(n)) -> minus#(m,n) minus#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(minus(m,n)) minus#(BIT0(m),BIT0(n)) -> minus#(m,n) minus#(BIT0(m),BIT0(n)) -> BIT0#(minus(m,n)) minus#(BIT0(m),BIT1(n)) -> minus#(m,n) minus#(BIT0(m),BIT1(n)) -> BIT0#(minus(m,n)) minus#(BIT0(m),BIT1(n)) -> PRE#(BIT0(minus(m,n))) minus#(BIT1(m),BIT0(n)) -> minus#(m,n) minus#(BIT1(m),BIT0(n)) -> le#(n,m) minus#(BIT1(m),BIT1(n)) -> minus#(m,n) minus#(BIT1(m),BIT1(n)) -> BIT0#(minus(m,n)) TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) TDG Processor: DPs: SUC#(NUMERAL(n)) -> SUC#(n) SUC#(NUMERAL(n)) -> NUMERAL#(SUC(n)) SUC#(BIT1(n)) -> SUC#(n) SUC#(BIT1(n)) -> BIT0#(SUC(n)) PRE#(NUMERAL(n)) -> PRE#(n) PRE#(NUMERAL(n)) -> NUMERAL#(PRE(n)) PRE#(BIT0(n)) -> PRE#(n) PRE#(BIT0(n)) -> eq#(n,0()) PRE#(BIT1(n)) -> BIT0#(n) plus#(NUMERAL(m),NUMERAL(n)) -> plus#(m,n) plus#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(plus(m,n)) plus#(BIT0(m),BIT0(n)) -> plus#(m,n) plus#(BIT0(m),BIT0(n)) -> BIT0#(plus(m,n)) plus#(BIT0(m),BIT1(n)) -> plus#(m,n) plus#(BIT1(m),BIT0(n)) -> plus#(m,n) plus#(BIT1(m),BIT1(n)) -> plus#(m,n) plus#(BIT1(m),BIT1(n)) -> SUC#(plus(m,n)) plus#(BIT1(m),BIT1(n)) -> BIT0#(SUC(plus(m,n))) mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) mult#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(mult(m,n)) mult#(BIT0(m),BIT0(n)) -> mult#(m,n) mult#(BIT0(m),BIT0(n)) -> BIT0#(mult(m,n)) mult#(BIT0(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) mult#(BIT0(m),BIT1(n)) -> mult#(m,n) mult#(BIT0(m),BIT1(n)) -> BIT0#(mult(m,n)) mult#(BIT0(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) mult#(BIT0(m),BIT1(n)) -> plus#(BIT0(m),BIT0(BIT0(mult(m,n)))) mult#(BIT1(m),BIT0(n)) -> mult#(m,n) mult#(BIT1(m),BIT0(n)) -> BIT0#(mult(m,n)) mult#(BIT1(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) mult#(BIT1(m),BIT0(n)) -> plus#(BIT0(n),BIT0(BIT0(mult(m,n)))) mult#(BIT1(m),BIT1(n)) -> mult#(m,n) mult#(BIT1(m),BIT1(n)) -> BIT0#(mult(m,n)) mult#(BIT1(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) mult#(BIT1(m),BIT1(n)) -> BIT0#(n) mult#(BIT1(m),BIT1(n)) -> plus#(BIT1(m),BIT0(n)) mult#(BIT1(m),BIT1(n)) -> plus#(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp#(NUMERAL(m),NUMERAL(n)) -> exp#(m,n) exp#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(exp(m,n)) exp#(0(),BIT0(n)) -> exp#(0(),n) exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) exp#(BIT0(m),BIT0(n)) -> exp#(BIT0(m),n) exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) exp#(BIT1(m),BIT0(n)) -> exp#(BIT1(m),n) exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) exp#(BIT0(m),BIT1(n)) -> exp#(BIT0(m),n) exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp#(BIT1(m),BIT1(n)) -> exp#(BIT1(m),n) exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN#(NUMERAL(n)) -> EVEN#(n) ODD#(NUMERAL(n)) -> ODD#(n) eq#(NUMERAL(m),NUMERAL(n)) -> eq#(m,n) eq#(BIT0(n),0()) -> eq#(n,0()) eq#(0(),BIT0(n)) -> eq#(0(),n) eq#(BIT0(m),BIT0(n)) -> eq#(m,n) eq#(BIT1(m),BIT1(n)) -> eq#(m,n) le#(NUMERAL(m),NUMERAL(n)) -> le#(m,n) le#(BIT0(n),0()) -> le#(n,0()) le#(BIT0(m),BIT0(n)) -> le#(m,n) le#(BIT0(m),BIT1(n)) -> le#(m,n) le#(BIT1(m),BIT0(n)) -> lt#(m,n) le#(BIT1(m),BIT1(n)) -> le#(m,n) lt#(NUMERAL(m),NUMERAL(n)) -> lt#(m,n) lt#(0(),BIT0(n)) -> lt#(0(),n) lt#(BIT0(m),BIT0(n)) -> lt#(m,n) lt#(BIT0(m),BIT1(n)) -> le#(m,n) lt#(BIT1(m),BIT0(n)) -> lt#(m,n) lt#(BIT1(m),BIT1(n)) -> lt#(m,n) ge#(NUMERAL(n),NUMERAL(m)) -> ge#(n,m) ge#(0(),BIT0(n)) -> ge#(0(),n) ge#(BIT0(n),BIT0(m)) -> ge#(n,m) ge#(BIT1(n),BIT0(m)) -> ge#(n,m) ge#(BIT0(n),BIT1(m)) -> gt#(n,m) ge#(BIT1(n),BIT1(m)) -> ge#(n,m) gt#(NUMERAL(n),NUMERAL(m)) -> gt#(n,m) gt#(BIT0(n),0()) -> gt#(n,0()) gt#(BIT0(n),BIT0(m)) -> gt#(n,m) gt#(BIT1(n),BIT0(m)) -> ge#(n,m) gt#(BIT0(n),BIT1(m)) -> gt#(n,m) gt#(BIT1(n),BIT1(m)) -> gt#(n,m) minus#(NUMERAL(m),NUMERAL(n)) -> minus#(m,n) minus#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(minus(m,n)) minus#(BIT0(m),BIT0(n)) -> minus#(m,n) minus#(BIT0(m),BIT0(n)) -> BIT0#(minus(m,n)) minus#(BIT0(m),BIT1(n)) -> minus#(m,n) minus#(BIT0(m),BIT1(n)) -> BIT0#(minus(m,n)) minus#(BIT0(m),BIT1(n)) -> PRE#(BIT0(minus(m,n))) minus#(BIT1(m),BIT0(n)) -> minus#(m,n) minus#(BIT1(m),BIT0(n)) -> le#(n,m) minus#(BIT1(m),BIT1(n)) -> minus#(m,n) minus#(BIT1(m),BIT1(n)) -> BIT0#(minus(m,n)) TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) graph: minus#(BIT1(m),BIT1(n)) -> minus#(m,n) -> minus#(BIT1(m),BIT1(n)) -> BIT0#(minus(m,n)) minus#(BIT1(m),BIT1(n)) -> minus#(m,n) -> minus#(BIT1(m),BIT1(n)) -> minus#(m,n) minus#(BIT1(m),BIT1(n)) -> minus#(m,n) -> minus#(BIT1(m),BIT0(n)) -> le#(n,m) minus#(BIT1(m),BIT1(n)) -> minus#(m,n) -> minus#(BIT1(m),BIT0(n)) -> minus#(m,n) minus#(BIT1(m),BIT1(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT1(n)) -> PRE#(BIT0(minus(m,n))) minus#(BIT1(m),BIT1(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT1(n)) -> BIT0#(minus(m,n)) minus#(BIT1(m),BIT1(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT1(n)) -> minus#(m,n) minus#(BIT1(m),BIT1(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT0(n)) -> BIT0#(minus(m,n)) minus#(BIT1(m),BIT1(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT0(n)) -> minus#(m,n) minus#(BIT1(m),BIT1(n)) -> minus#(m,n) -> minus#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(minus(m,n)) minus#(BIT1(m),BIT1(n)) -> minus#(m,n) -> minus#(NUMERAL(m),NUMERAL(n)) -> minus#(m,n) minus#(BIT1(m),BIT0(n)) -> minus#(m,n) -> minus#(BIT1(m),BIT1(n)) -> BIT0#(minus(m,n)) minus#(BIT1(m),BIT0(n)) -> minus#(m,n) -> minus#(BIT1(m),BIT1(n)) -> minus#(m,n) minus#(BIT1(m),BIT0(n)) -> minus#(m,n) -> minus#(BIT1(m),BIT0(n)) -> le#(n,m) minus#(BIT1(m),BIT0(n)) -> minus#(m,n) -> minus#(BIT1(m),BIT0(n)) -> minus#(m,n) minus#(BIT1(m),BIT0(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT1(n)) -> PRE#(BIT0(minus(m,n))) minus#(BIT1(m),BIT0(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT1(n)) -> BIT0#(minus(m,n)) minus#(BIT1(m),BIT0(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT1(n)) -> minus#(m,n) minus#(BIT1(m),BIT0(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT0(n)) -> BIT0#(minus(m,n)) minus#(BIT1(m),BIT0(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT0(n)) -> minus#(m,n) minus#(BIT1(m),BIT0(n)) -> minus#(m,n) -> minus#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(minus(m,n)) minus#(BIT1(m),BIT0(n)) -> minus#(m,n) -> minus#(NUMERAL(m),NUMERAL(n)) -> minus#(m,n) minus#(BIT1(m),BIT0(n)) -> le#(n,m) -> le#(BIT1(m),BIT1(n)) -> le#(m,n) minus#(BIT1(m),BIT0(n)) -> le#(n,m) -> le#(BIT1(m),BIT0(n)) -> lt#(m,n) minus#(BIT1(m),BIT0(n)) -> le#(n,m) -> le#(BIT0(m),BIT1(n)) -> le#(m,n) minus#(BIT1(m),BIT0(n)) -> le#(n,m) -> le#(BIT0(m),BIT0(n)) -> le#(m,n) minus#(BIT1(m),BIT0(n)) -> le#(n,m) -> le#(BIT0(n),0()) -> le#(n,0()) minus#(BIT1(m),BIT0(n)) -> le#(n,m) -> le#(NUMERAL(m),NUMERAL(n)) -> le#(m,n) minus#(BIT0(m),BIT1(n)) -> minus#(m,n) -> minus#(BIT1(m),BIT1(n)) -> BIT0#(minus(m,n)) minus#(BIT0(m),BIT1(n)) -> minus#(m,n) -> minus#(BIT1(m),BIT1(n)) -> minus#(m,n) minus#(BIT0(m),BIT1(n)) -> minus#(m,n) -> minus#(BIT1(m),BIT0(n)) -> le#(n,m) minus#(BIT0(m),BIT1(n)) -> minus#(m,n) -> minus#(BIT1(m),BIT0(n)) -> minus#(m,n) minus#(BIT0(m),BIT1(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT1(n)) -> PRE#(BIT0(minus(m,n))) minus#(BIT0(m),BIT1(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT1(n)) -> BIT0#(minus(m,n)) minus#(BIT0(m),BIT1(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT1(n)) -> minus#(m,n) minus#(BIT0(m),BIT1(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT0(n)) -> BIT0#(minus(m,n)) minus#(BIT0(m),BIT1(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT0(n)) -> minus#(m,n) minus#(BIT0(m),BIT1(n)) -> minus#(m,n) -> minus#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(minus(m,n)) minus#(BIT0(m),BIT1(n)) -> minus#(m,n) -> minus#(NUMERAL(m),NUMERAL(n)) -> minus#(m,n) minus#(BIT0(m),BIT1(n)) -> PRE#(BIT0(minus(m,n))) -> PRE#(BIT1(n)) -> BIT0#(n) minus#(BIT0(m),BIT1(n)) -> PRE#(BIT0(minus(m,n))) -> PRE#(BIT0(n)) -> eq#(n,0()) minus#(BIT0(m),BIT1(n)) -> PRE#(BIT0(minus(m,n))) -> PRE#(BIT0(n)) -> PRE#(n) minus#(BIT0(m),BIT1(n)) -> PRE#(BIT0(minus(m,n))) -> PRE#(NUMERAL(n)) -> NUMERAL#(PRE(n)) minus#(BIT0(m),BIT1(n)) -> PRE#(BIT0(minus(m,n))) -> PRE#(NUMERAL(n)) -> PRE#(n) minus#(BIT0(m),BIT0(n)) -> minus#(m,n) -> minus#(BIT1(m),BIT1(n)) -> BIT0#(minus(m,n)) minus#(BIT0(m),BIT0(n)) -> minus#(m,n) -> minus#(BIT1(m),BIT1(n)) -> minus#(m,n) minus#(BIT0(m),BIT0(n)) -> minus#(m,n) -> minus#(BIT1(m),BIT0(n)) -> le#(n,m) minus#(BIT0(m),BIT0(n)) -> minus#(m,n) -> minus#(BIT1(m),BIT0(n)) -> minus#(m,n) minus#(BIT0(m),BIT0(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT1(n)) -> PRE#(BIT0(minus(m,n))) minus#(BIT0(m),BIT0(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT1(n)) -> BIT0#(minus(m,n)) minus#(BIT0(m),BIT0(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT1(n)) -> minus#(m,n) minus#(BIT0(m),BIT0(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT0(n)) -> BIT0#(minus(m,n)) minus#(BIT0(m),BIT0(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT0(n)) -> minus#(m,n) minus#(BIT0(m),BIT0(n)) -> minus#(m,n) -> minus#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(minus(m,n)) minus#(BIT0(m),BIT0(n)) -> minus#(m,n) -> minus#(NUMERAL(m),NUMERAL(n)) -> minus#(m,n) minus#(NUMERAL(m),NUMERAL(n)) -> minus#(m,n) -> minus#(BIT1(m),BIT1(n)) -> BIT0#(minus(m,n)) minus#(NUMERAL(m),NUMERAL(n)) -> minus#(m,n) -> minus#(BIT1(m),BIT1(n)) -> minus#(m,n) minus#(NUMERAL(m),NUMERAL(n)) -> minus#(m,n) -> minus#(BIT1(m),BIT0(n)) -> le#(n,m) minus#(NUMERAL(m),NUMERAL(n)) -> minus#(m,n) -> minus#(BIT1(m),BIT0(n)) -> minus#(m,n) minus#(NUMERAL(m),NUMERAL(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT1(n)) -> PRE#(BIT0(minus(m,n))) minus#(NUMERAL(m),NUMERAL(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT1(n)) -> BIT0#(minus(m,n)) minus#(NUMERAL(m),NUMERAL(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT1(n)) -> minus#(m,n) minus#(NUMERAL(m),NUMERAL(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT0(n)) -> BIT0#(minus(m,n)) minus#(NUMERAL(m),NUMERAL(n)) -> minus#(m,n) -> minus#(BIT0(m),BIT0(n)) -> minus#(m,n) minus#(NUMERAL(m),NUMERAL(n)) -> minus#(m,n) -> minus#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(minus(m,n)) minus#(NUMERAL(m),NUMERAL(n)) -> minus#(m,n) -> minus#(NUMERAL(m),NUMERAL(n)) -> minus#(m,n) gt#(BIT1(n),BIT1(m)) -> gt#(n,m) -> gt#(BIT1(n),BIT1(m)) -> gt#(n,m) gt#(BIT1(n),BIT1(m)) -> gt#(n,m) -> gt#(BIT0(n),BIT1(m)) -> gt#(n,m) gt#(BIT1(n),BIT1(m)) -> gt#(n,m) -> gt#(BIT1(n),BIT0(m)) -> ge#(n,m) gt#(BIT1(n),BIT1(m)) -> gt#(n,m) -> gt#(BIT0(n),BIT0(m)) -> gt#(n,m) gt#(BIT1(n),BIT1(m)) -> gt#(n,m) -> gt#(BIT0(n),0()) -> gt#(n,0()) gt#(BIT1(n),BIT1(m)) -> gt#(n,m) -> gt#(NUMERAL(n),NUMERAL(m)) -> gt#(n,m) gt#(BIT1(n),BIT0(m)) -> ge#(n,m) -> ge#(BIT1(n),BIT1(m)) -> ge#(n,m) gt#(BIT1(n),BIT0(m)) -> ge#(n,m) -> ge#(BIT0(n),BIT1(m)) -> gt#(n,m) gt#(BIT1(n),BIT0(m)) -> ge#(n,m) -> ge#(BIT1(n),BIT0(m)) -> ge#(n,m) gt#(BIT1(n),BIT0(m)) -> ge#(n,m) -> ge#(BIT0(n),BIT0(m)) -> ge#(n,m) gt#(BIT1(n),BIT0(m)) -> ge#(n,m) -> ge#(0(),BIT0(n)) -> ge#(0(),n) gt#(BIT1(n),BIT0(m)) -> ge#(n,m) -> ge#(NUMERAL(n),NUMERAL(m)) -> ge#(n,m) gt#(BIT0(n),BIT1(m)) -> gt#(n,m) -> gt#(BIT1(n),BIT1(m)) -> gt#(n,m) gt#(BIT0(n),BIT1(m)) -> gt#(n,m) -> gt#(BIT0(n),BIT1(m)) -> gt#(n,m) gt#(BIT0(n),BIT1(m)) -> gt#(n,m) -> gt#(BIT1(n),BIT0(m)) -> ge#(n,m) gt#(BIT0(n),BIT1(m)) -> gt#(n,m) -> gt#(BIT0(n),BIT0(m)) -> gt#(n,m) gt#(BIT0(n),BIT1(m)) -> gt#(n,m) -> gt#(BIT0(n),0()) -> gt#(n,0()) gt#(BIT0(n),BIT1(m)) -> gt#(n,m) -> gt#(NUMERAL(n),NUMERAL(m)) -> gt#(n,m) gt#(BIT0(n),BIT0(m)) -> gt#(n,m) -> gt#(BIT1(n),BIT1(m)) -> gt#(n,m) gt#(BIT0(n),BIT0(m)) -> gt#(n,m) -> gt#(BIT0(n),BIT1(m)) -> gt#(n,m) gt#(BIT0(n),BIT0(m)) -> gt#(n,m) -> gt#(BIT1(n),BIT0(m)) -> ge#(n,m) gt#(BIT0(n),BIT0(m)) -> gt#(n,m) -> gt#(BIT0(n),BIT0(m)) -> gt#(n,m) gt#(BIT0(n),BIT0(m)) -> gt#(n,m) -> gt#(BIT0(n),0()) -> gt#(n,0()) gt#(BIT0(n),BIT0(m)) -> gt#(n,m) -> gt#(NUMERAL(n),NUMERAL(m)) -> gt#(n,m) gt#(BIT0(n),0()) -> gt#(n,0()) -> gt#(BIT1(n),BIT1(m)) -> gt#(n,m) gt#(BIT0(n),0()) -> gt#(n,0()) -> gt#(BIT0(n),BIT1(m)) -> gt#(n,m) gt#(BIT0(n),0()) -> gt#(n,0()) -> gt#(BIT1(n),BIT0(m)) -> ge#(n,m) gt#(BIT0(n),0()) -> gt#(n,0()) -> gt#(BIT0(n),BIT0(m)) -> gt#(n,m) gt#(BIT0(n),0()) -> gt#(n,0()) -> gt#(BIT0(n),0()) -> gt#(n,0()) gt#(BIT0(n),0()) -> gt#(n,0()) -> gt#(NUMERAL(n),NUMERAL(m)) -> gt#(n,m) gt#(NUMERAL(n),NUMERAL(m)) -> gt#(n,m) -> gt#(BIT1(n),BIT1(m)) -> gt#(n,m) gt#(NUMERAL(n),NUMERAL(m)) -> gt#(n,m) -> gt#(BIT0(n),BIT1(m)) -> gt#(n,m) gt#(NUMERAL(n),NUMERAL(m)) -> gt#(n,m) -> gt#(BIT1(n),BIT0(m)) -> ge#(n,m) gt#(NUMERAL(n),NUMERAL(m)) -> gt#(n,m) -> gt#(BIT0(n),BIT0(m)) -> gt#(n,m) gt#(NUMERAL(n),NUMERAL(m)) -> gt#(n,m) -> gt#(BIT0(n),0()) -> gt#(n,0()) gt#(NUMERAL(n),NUMERAL(m)) -> gt#(n,m) -> gt#(NUMERAL(n),NUMERAL(m)) -> gt#(n,m) ge#(BIT1(n),BIT1(m)) -> ge#(n,m) -> ge#(BIT1(n),BIT1(m)) -> ge#(n,m) ge#(BIT1(n),BIT1(m)) -> ge#(n,m) -> ge#(BIT0(n),BIT1(m)) -> gt#(n,m) ge#(BIT1(n),BIT1(m)) -> ge#(n,m) -> ge#(BIT1(n),BIT0(m)) -> ge#(n,m) ge#(BIT1(n),BIT1(m)) -> ge#(n,m) -> ge#(BIT0(n),BIT0(m)) -> ge#(n,m) ge#(BIT1(n),BIT1(m)) -> ge#(n,m) -> ge#(0(),BIT0(n)) -> ge#(0(),n) ge#(BIT1(n),BIT1(m)) -> ge#(n,m) -> ge#(NUMERAL(n),NUMERAL(m)) -> ge#(n,m) ge#(BIT1(n),BIT0(m)) -> ge#(n,m) -> ge#(BIT1(n),BIT1(m)) -> ge#(n,m) ge#(BIT1(n),BIT0(m)) -> ge#(n,m) -> ge#(BIT0(n),BIT1(m)) -> gt#(n,m) ge#(BIT1(n),BIT0(m)) -> ge#(n,m) -> ge#(BIT1(n),BIT0(m)) -> ge#(n,m) ge#(BIT1(n),BIT0(m)) -> ge#(n,m) -> ge#(BIT0(n),BIT0(m)) -> ge#(n,m) ge#(BIT1(n),BIT0(m)) -> ge#(n,m) -> ge#(0(),BIT0(n)) -> ge#(0(),n) ge#(BIT1(n),BIT0(m)) -> ge#(n,m) -> ge#(NUMERAL(n),NUMERAL(m)) -> ge#(n,m) ge#(BIT0(n),BIT1(m)) -> gt#(n,m) -> gt#(BIT1(n),BIT1(m)) -> gt#(n,m) ge#(BIT0(n),BIT1(m)) -> gt#(n,m) -> gt#(BIT0(n),BIT1(m)) -> gt#(n,m) ge#(BIT0(n),BIT1(m)) -> gt#(n,m) -> gt#(BIT1(n),BIT0(m)) -> ge#(n,m) ge#(BIT0(n),BIT1(m)) -> gt#(n,m) -> gt#(BIT0(n),BIT0(m)) -> gt#(n,m) ge#(BIT0(n),BIT1(m)) -> gt#(n,m) -> gt#(BIT0(n),0()) -> gt#(n,0()) ge#(BIT0(n),BIT1(m)) -> gt#(n,m) -> gt#(NUMERAL(n),NUMERAL(m)) -> gt#(n,m) ge#(BIT0(n),BIT0(m)) -> ge#(n,m) -> ge#(BIT1(n),BIT1(m)) -> ge#(n,m) ge#(BIT0(n),BIT0(m)) -> ge#(n,m) -> ge#(BIT0(n),BIT1(m)) -> gt#(n,m) ge#(BIT0(n),BIT0(m)) -> ge#(n,m) -> ge#(BIT1(n),BIT0(m)) -> ge#(n,m) ge#(BIT0(n),BIT0(m)) -> ge#(n,m) -> ge#(BIT0(n),BIT0(m)) -> ge#(n,m) ge#(BIT0(n),BIT0(m)) -> ge#(n,m) -> ge#(0(),BIT0(n)) -> ge#(0(),n) ge#(BIT0(n),BIT0(m)) -> ge#(n,m) -> ge#(NUMERAL(n),NUMERAL(m)) -> ge#(n,m) ge#(NUMERAL(n),NUMERAL(m)) -> ge#(n,m) -> ge#(BIT1(n),BIT1(m)) -> ge#(n,m) ge#(NUMERAL(n),NUMERAL(m)) -> ge#(n,m) -> ge#(BIT0(n),BIT1(m)) -> gt#(n,m) ge#(NUMERAL(n),NUMERAL(m)) -> ge#(n,m) -> ge#(BIT1(n),BIT0(m)) -> ge#(n,m) ge#(NUMERAL(n),NUMERAL(m)) -> ge#(n,m) -> ge#(BIT0(n),BIT0(m)) -> ge#(n,m) ge#(NUMERAL(n),NUMERAL(m)) -> ge#(n,m) -> ge#(0(),BIT0(n)) -> ge#(0(),n) ge#(NUMERAL(n),NUMERAL(m)) -> ge#(n,m) -> ge#(NUMERAL(n),NUMERAL(m)) -> ge#(n,m) ge#(0(),BIT0(n)) -> ge#(0(),n) -> ge#(BIT1(n),BIT1(m)) -> ge#(n,m) ge#(0(),BIT0(n)) -> ge#(0(),n) -> ge#(BIT0(n),BIT1(m)) -> gt#(n,m) ge#(0(),BIT0(n)) -> ge#(0(),n) -> ge#(BIT1(n),BIT0(m)) -> ge#(n,m) ge#(0(),BIT0(n)) -> ge#(0(),n) -> ge#(BIT0(n),BIT0(m)) -> ge#(n,m) ge#(0(),BIT0(n)) -> ge#(0(),n) -> ge#(0(),BIT0(n)) -> ge#(0(),n) ge#(0(),BIT0(n)) -> ge#(0(),n) -> ge#(NUMERAL(n),NUMERAL(m)) -> ge#(n,m) lt#(BIT1(m),BIT1(n)) -> lt#(m,n) -> lt#(BIT1(m),BIT1(n)) -> lt#(m,n) lt#(BIT1(m),BIT1(n)) -> lt#(m,n) -> lt#(BIT1(m),BIT0(n)) -> lt#(m,n) lt#(BIT1(m),BIT1(n)) -> lt#(m,n) -> lt#(BIT0(m),BIT1(n)) -> le#(m,n) lt#(BIT1(m),BIT1(n)) -> lt#(m,n) -> lt#(BIT0(m),BIT0(n)) -> lt#(m,n) lt#(BIT1(m),BIT1(n)) -> lt#(m,n) -> lt#(0(),BIT0(n)) -> lt#(0(),n) lt#(BIT1(m),BIT1(n)) -> lt#(m,n) -> lt#(NUMERAL(m),NUMERAL(n)) -> lt#(m,n) lt#(BIT1(m),BIT0(n)) -> lt#(m,n) -> lt#(BIT1(m),BIT1(n)) -> lt#(m,n) lt#(BIT1(m),BIT0(n)) -> lt#(m,n) -> lt#(BIT1(m),BIT0(n)) -> lt#(m,n) lt#(BIT1(m),BIT0(n)) -> lt#(m,n) -> lt#(BIT0(m),BIT1(n)) -> le#(m,n) lt#(BIT1(m),BIT0(n)) -> lt#(m,n) -> lt#(BIT0(m),BIT0(n)) -> lt#(m,n) lt#(BIT1(m),BIT0(n)) -> lt#(m,n) -> lt#(0(),BIT0(n)) -> lt#(0(),n) lt#(BIT1(m),BIT0(n)) -> lt#(m,n) -> lt#(NUMERAL(m),NUMERAL(n)) -> lt#(m,n) lt#(BIT0(m),BIT1(n)) -> le#(m,n) -> le#(BIT1(m),BIT1(n)) -> le#(m,n) lt#(BIT0(m),BIT1(n)) -> le#(m,n) -> le#(BIT1(m),BIT0(n)) -> lt#(m,n) lt#(BIT0(m),BIT1(n)) -> le#(m,n) -> le#(BIT0(m),BIT1(n)) -> le#(m,n) lt#(BIT0(m),BIT1(n)) -> le#(m,n) -> le#(BIT0(m),BIT0(n)) -> le#(m,n) lt#(BIT0(m),BIT1(n)) -> le#(m,n) -> le#(BIT0(n),0()) -> le#(n,0()) lt#(BIT0(m),BIT1(n)) -> le#(m,n) -> le#(NUMERAL(m),NUMERAL(n)) -> le#(m,n) lt#(BIT0(m),BIT0(n)) -> lt#(m,n) -> lt#(BIT1(m),BIT1(n)) -> lt#(m,n) lt#(BIT0(m),BIT0(n)) -> lt#(m,n) -> lt#(BIT1(m),BIT0(n)) -> lt#(m,n) lt#(BIT0(m),BIT0(n)) -> lt#(m,n) -> lt#(BIT0(m),BIT1(n)) -> le#(m,n) lt#(BIT0(m),BIT0(n)) -> lt#(m,n) -> lt#(BIT0(m),BIT0(n)) -> lt#(m,n) lt#(BIT0(m),BIT0(n)) -> lt#(m,n) -> lt#(0(),BIT0(n)) -> lt#(0(),n) lt#(BIT0(m),BIT0(n)) -> lt#(m,n) -> lt#(NUMERAL(m),NUMERAL(n)) -> lt#(m,n) lt#(NUMERAL(m),NUMERAL(n)) -> lt#(m,n) -> lt#(BIT1(m),BIT1(n)) -> lt#(m,n) lt#(NUMERAL(m),NUMERAL(n)) -> lt#(m,n) -> lt#(BIT1(m),BIT0(n)) -> lt#(m,n) lt#(NUMERAL(m),NUMERAL(n)) -> lt#(m,n) -> lt#(BIT0(m),BIT1(n)) -> le#(m,n) lt#(NUMERAL(m),NUMERAL(n)) -> lt#(m,n) -> lt#(BIT0(m),BIT0(n)) -> lt#(m,n) lt#(NUMERAL(m),NUMERAL(n)) -> lt#(m,n) -> lt#(0(),BIT0(n)) -> lt#(0(),n) lt#(NUMERAL(m),NUMERAL(n)) -> lt#(m,n) -> lt#(NUMERAL(m),NUMERAL(n)) -> lt#(m,n) lt#(0(),BIT0(n)) -> lt#(0(),n) -> lt#(BIT1(m),BIT1(n)) -> lt#(m,n) lt#(0(),BIT0(n)) -> lt#(0(),n) -> lt#(BIT1(m),BIT0(n)) -> lt#(m,n) lt#(0(),BIT0(n)) -> lt#(0(),n) -> lt#(BIT0(m),BIT1(n)) -> le#(m,n) lt#(0(),BIT0(n)) -> lt#(0(),n) -> lt#(BIT0(m),BIT0(n)) -> lt#(m,n) lt#(0(),BIT0(n)) -> lt#(0(),n) -> lt#(0(),BIT0(n)) -> lt#(0(),n) lt#(0(),BIT0(n)) -> lt#(0(),n) -> lt#(NUMERAL(m),NUMERAL(n)) -> lt#(m,n) le#(BIT1(m),BIT1(n)) -> le#(m,n) -> le#(BIT1(m),BIT1(n)) -> le#(m,n) le#(BIT1(m),BIT1(n)) -> le#(m,n) -> le#(BIT1(m),BIT0(n)) -> lt#(m,n) le#(BIT1(m),BIT1(n)) -> le#(m,n) -> le#(BIT0(m),BIT1(n)) -> le#(m,n) le#(BIT1(m),BIT1(n)) -> le#(m,n) -> le#(BIT0(m),BIT0(n)) -> le#(m,n) le#(BIT1(m),BIT1(n)) -> le#(m,n) -> le#(BIT0(n),0()) -> le#(n,0()) le#(BIT1(m),BIT1(n)) -> le#(m,n) -> le#(NUMERAL(m),NUMERAL(n)) -> le#(m,n) le#(BIT1(m),BIT0(n)) -> lt#(m,n) -> lt#(BIT1(m),BIT1(n)) -> lt#(m,n) le#(BIT1(m),BIT0(n)) -> lt#(m,n) -> lt#(BIT1(m),BIT0(n)) -> lt#(m,n) le#(BIT1(m),BIT0(n)) -> lt#(m,n) -> lt#(BIT0(m),BIT1(n)) -> le#(m,n) le#(BIT1(m),BIT0(n)) -> lt#(m,n) -> lt#(BIT0(m),BIT0(n)) -> lt#(m,n) le#(BIT1(m),BIT0(n)) -> lt#(m,n) -> lt#(0(),BIT0(n)) -> lt#(0(),n) le#(BIT1(m),BIT0(n)) -> lt#(m,n) -> lt#(NUMERAL(m),NUMERAL(n)) -> lt#(m,n) le#(BIT0(m),BIT1(n)) -> le#(m,n) -> le#(BIT1(m),BIT1(n)) -> le#(m,n) le#(BIT0(m),BIT1(n)) -> le#(m,n) -> le#(BIT1(m),BIT0(n)) -> lt#(m,n) le#(BIT0(m),BIT1(n)) -> le#(m,n) -> le#(BIT0(m),BIT1(n)) -> le#(m,n) le#(BIT0(m),BIT1(n)) -> le#(m,n) -> le#(BIT0(m),BIT0(n)) -> le#(m,n) le#(BIT0(m),BIT1(n)) -> le#(m,n) -> le#(BIT0(n),0()) -> le#(n,0()) le#(BIT0(m),BIT1(n)) -> le#(m,n) -> le#(NUMERAL(m),NUMERAL(n)) -> le#(m,n) le#(BIT0(m),BIT0(n)) -> le#(m,n) -> le#(BIT1(m),BIT1(n)) -> le#(m,n) le#(BIT0(m),BIT0(n)) -> le#(m,n) -> le#(BIT1(m),BIT0(n)) -> lt#(m,n) le#(BIT0(m),BIT0(n)) -> le#(m,n) -> le#(BIT0(m),BIT1(n)) -> le#(m,n) le#(BIT0(m),BIT0(n)) -> le#(m,n) -> le#(BIT0(m),BIT0(n)) -> le#(m,n) le#(BIT0(m),BIT0(n)) -> le#(m,n) -> le#(BIT0(n),0()) -> le#(n,0()) le#(BIT0(m),BIT0(n)) -> le#(m,n) -> le#(NUMERAL(m),NUMERAL(n)) -> le#(m,n) le#(BIT0(n),0()) -> le#(n,0()) -> le#(BIT1(m),BIT1(n)) -> le#(m,n) le#(BIT0(n),0()) -> le#(n,0()) -> le#(BIT1(m),BIT0(n)) -> lt#(m,n) le#(BIT0(n),0()) -> le#(n,0()) -> le#(BIT0(m),BIT1(n)) -> le#(m,n) le#(BIT0(n),0()) -> le#(n,0()) -> le#(BIT0(m),BIT0(n)) -> le#(m,n) le#(BIT0(n),0()) -> le#(n,0()) -> le#(BIT0(n),0()) -> le#(n,0()) le#(BIT0(n),0()) -> le#(n,0()) -> le#(NUMERAL(m),NUMERAL(n)) -> le#(m,n) le#(NUMERAL(m),NUMERAL(n)) -> le#(m,n) -> le#(BIT1(m),BIT1(n)) -> le#(m,n) le#(NUMERAL(m),NUMERAL(n)) -> le#(m,n) -> le#(BIT1(m),BIT0(n)) -> lt#(m,n) le#(NUMERAL(m),NUMERAL(n)) -> le#(m,n) -> le#(BIT0(m),BIT1(n)) -> le#(m,n) le#(NUMERAL(m),NUMERAL(n)) -> le#(m,n) -> le#(BIT0(m),BIT0(n)) -> le#(m,n) le#(NUMERAL(m),NUMERAL(n)) -> le#(m,n) -> le#(BIT0(n),0()) -> le#(n,0()) le#(NUMERAL(m),NUMERAL(n)) -> le#(m,n) -> le#(NUMERAL(m),NUMERAL(n)) -> le#(m,n) ODD#(NUMERAL(n)) -> ODD#(n) -> ODD#(NUMERAL(n)) -> ODD#(n) EVEN#(NUMERAL(n)) -> EVEN#(n) -> EVEN#(NUMERAL(n)) -> EVEN#(n) exp#(BIT1(m),BIT1(n)) -> exp#(BIT1(m),n) -> exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) exp#(BIT1(m),BIT1(n)) -> exp#(BIT1(m),n) -> exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) exp#(BIT1(m),BIT1(n)) -> exp#(BIT1(m),n) -> exp#(BIT1(m),BIT1(n)) -> exp#(BIT1(m),n) exp#(BIT1(m),BIT1(n)) -> exp#(BIT1(m),n) -> exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp#(BIT1(m),BIT1(n)) -> exp#(BIT1(m),n) -> exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) exp#(BIT1(m),BIT1(n)) -> exp#(BIT1(m),n) -> exp#(BIT0(m),BIT1(n)) -> exp#(BIT0(m),n) exp#(BIT1(m),BIT1(n)) -> exp#(BIT1(m),n) -> exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) exp#(BIT1(m),BIT1(n)) -> exp#(BIT1(m),n) -> exp#(BIT1(m),BIT0(n)) -> exp#(BIT1(m),n) exp#(BIT1(m),BIT1(n)) -> exp#(BIT1(m),n) -> exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) exp#(BIT1(m),BIT1(n)) -> exp#(BIT1(m),n) -> exp#(BIT0(m),BIT0(n)) -> exp#(BIT0(m),n) exp#(BIT1(m),BIT1(n)) -> exp#(BIT1(m),n) -> exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) exp#(BIT1(m),BIT1(n)) -> exp#(BIT1(m),n) -> exp#(0(),BIT0(n)) -> exp#(0(),n) exp#(BIT1(m),BIT1(n)) -> exp#(BIT1(m),n) -> exp#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(exp(m,n)) exp#(BIT1(m),BIT1(n)) -> exp#(BIT1(m),n) -> exp#(NUMERAL(m),NUMERAL(n)) -> exp#(m,n) exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT1(n)) -> plus#(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT1(n)) -> plus#(BIT1(m),BIT0(n)) exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(n) exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(mult(m,n)) exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT1(n)) -> mult#(m,n) exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT0(n)) -> plus#(BIT0(n),BIT0(BIT0(mult(m,n)))) exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT0(n)) -> BIT0#(mult(m,n)) exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT0(n)) -> mult#(m,n) exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) -> mult#(BIT0(m),BIT1(n)) -> plus#(BIT0(m),BIT0(BIT0(mult(m,n)))) exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) -> mult#(BIT0(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) -> mult#(BIT0(m),BIT1(n)) -> BIT0#(mult(m,n)) exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) -> mult#(BIT0(m),BIT1(n)) -> mult#(m,n) exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) -> mult#(BIT0(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) -> mult#(BIT0(m),BIT0(n)) -> BIT0#(mult(m,n)) exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) -> mult#(BIT0(m),BIT0(n)) -> mult#(m,n) exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) -> mult#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(mult(m,n)) exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) -> mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT1(n)) -> plus#(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT1(n)) -> plus#(BIT1(m),BIT0(n)) exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(n) exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(mult(m,n)) exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT1(n)) -> mult#(m,n) exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT0(n)) -> plus#(BIT0(n),BIT0(BIT0(mult(m,n)))) exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT0(n)) -> BIT0#(mult(m,n)) exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT0(n)) -> mult#(m,n) exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) -> mult#(BIT0(m),BIT1(n)) -> plus#(BIT0(m),BIT0(BIT0(mult(m,n)))) exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) -> mult#(BIT0(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) -> mult#(BIT0(m),BIT1(n)) -> BIT0#(mult(m,n)) exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) -> mult#(BIT0(m),BIT1(n)) -> mult#(m,n) exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) -> mult#(BIT0(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) -> mult#(BIT0(m),BIT0(n)) -> BIT0#(mult(m,n)) exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) -> mult#(BIT0(m),BIT0(n)) -> mult#(m,n) exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) -> mult#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(mult(m,n)) exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) -> mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) exp#(BIT1(m),BIT0(n)) -> exp#(BIT1(m),n) -> exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) exp#(BIT1(m),BIT0(n)) -> exp#(BIT1(m),n) -> exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) exp#(BIT1(m),BIT0(n)) -> exp#(BIT1(m),n) -> exp#(BIT1(m),BIT1(n)) -> exp#(BIT1(m),n) exp#(BIT1(m),BIT0(n)) -> exp#(BIT1(m),n) -> exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp#(BIT1(m),BIT0(n)) -> exp#(BIT1(m),n) -> exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) exp#(BIT1(m),BIT0(n)) -> exp#(BIT1(m),n) -> exp#(BIT0(m),BIT1(n)) -> exp#(BIT0(m),n) exp#(BIT1(m),BIT0(n)) -> exp#(BIT1(m),n) -> exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) exp#(BIT1(m),BIT0(n)) -> exp#(BIT1(m),n) -> exp#(BIT1(m),BIT0(n)) -> exp#(BIT1(m),n) exp#(BIT1(m),BIT0(n)) -> exp#(BIT1(m),n) -> exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) exp#(BIT1(m),BIT0(n)) -> exp#(BIT1(m),n) -> exp#(BIT0(m),BIT0(n)) -> exp#(BIT0(m),n) exp#(BIT1(m),BIT0(n)) -> exp#(BIT1(m),n) -> exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) exp#(BIT1(m),BIT0(n)) -> exp#(BIT1(m),n) -> exp#(0(),BIT0(n)) -> exp#(0(),n) exp#(BIT1(m),BIT0(n)) -> exp#(BIT1(m),n) -> exp#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(exp(m,n)) exp#(BIT1(m),BIT0(n)) -> exp#(BIT1(m),n) -> exp#(NUMERAL(m),NUMERAL(n)) -> exp#(m,n) exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT1(n)) -> plus#(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT1(n)) -> plus#(BIT1(m),BIT0(n)) exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(n) exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(mult(m,n)) exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT1(n)) -> mult#(m,n) exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT0(n)) -> plus#(BIT0(n),BIT0(BIT0(mult(m,n)))) exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT0(n)) -> BIT0#(mult(m,n)) exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) -> mult#(BIT1(m),BIT0(n)) -> mult#(m,n) exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) -> mult#(BIT0(m),BIT1(n)) -> plus#(BIT0(m),BIT0(BIT0(mult(m,n)))) exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) -> mult#(BIT0(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) -> mult#(BIT0(m),BIT1(n)) -> BIT0#(mult(m,n)) exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) -> mult#(BIT0(m),BIT1(n)) -> mult#(m,n) exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) -> mult#(BIT0(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) -> mult#(BIT0(m),BIT0(n)) -> BIT0#(mult(m,n)) exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) -> mult#(BIT0(m),BIT0(n)) -> mult#(m,n) exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) -> mult#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(mult(m,n)) exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) -> mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) exp#(BIT0(m),BIT1(n)) -> exp#(BIT0(m),n) -> exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) exp#(BIT0(m),BIT1(n)) -> exp#(BIT0(m),n) -> exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) exp#(BIT0(m),BIT1(n)) -> exp#(BIT0(m),n) -> exp#(BIT1(m),BIT1(n)) -> exp#(BIT1(m),n) exp#(BIT0(m),BIT1(n)) -> exp#(BIT0(m),n) -> exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp#(BIT0(m),BIT1(n)) -> exp#(BIT0(m),n) -> exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) exp#(BIT0(m),BIT1(n)) -> exp#(BIT0(m),n) -> exp#(BIT0(m),BIT1(n)) -> exp#(BIT0(m),n) exp#(BIT0(m),BIT1(n)) -> exp#(BIT0(m),n) -> exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) exp#(BIT0(m),BIT1(n)) -> exp#(BIT0(m),n) -> exp#(BIT1(m),BIT0(n)) -> exp#(BIT1(m),n) exp#(BIT0(m),BIT1(n)) -> exp#(BIT0(m),n) -> exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) exp#(BIT0(m),BIT1(n)) -> exp#(BIT0(m),n) -> exp#(BIT0(m),BIT0(n)) -> exp#(BIT0(m),n) exp#(BIT0(m),BIT1(n)) -> exp#(BIT0(m),n) -> exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) exp#(BIT0(m),BIT1(n)) -> exp#(BIT0(m),n) -> exp#(0(),BIT0(n)) -> exp#(0(),n) exp#(BIT0(m),BIT1(n)) -> exp#(BIT0(m),n) -> exp#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(exp(m,n)) exp#(BIT0(m),BIT1(n)) -> exp#(BIT0(m),n) -> exp#(NUMERAL(m),NUMERAL(n)) -> exp#(m,n) exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT1(n)) -> plus#(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT1(n)) -> plus#(BIT1(m),BIT0(n)) exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(n) exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(mult(m,n)) exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT1(n)) -> mult#(m,n) exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT0(n)) -> plus#(BIT0(n),BIT0(BIT0(mult(m,n)))) exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT0(n)) -> BIT0#(mult(m,n)) exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT0(n)) -> mult#(m,n) exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) -> mult#(BIT0(m),BIT1(n)) -> plus#(BIT0(m),BIT0(BIT0(mult(m,n)))) exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) -> mult#(BIT0(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) -> mult#(BIT0(m),BIT1(n)) -> BIT0#(mult(m,n)) exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) -> mult#(BIT0(m),BIT1(n)) -> mult#(m,n) exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) -> mult#(BIT0(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) -> mult#(BIT0(m),BIT0(n)) -> BIT0#(mult(m,n)) exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) -> mult#(BIT0(m),BIT0(n)) -> mult#(m,n) exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) -> mult#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(mult(m,n)) exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) -> mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT1(n)) -> plus#(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT1(n)) -> plus#(BIT1(m),BIT0(n)) exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(n) exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(mult(m,n)) exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT1(n)) -> mult#(m,n) exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT0(n)) -> plus#(BIT0(n),BIT0(BIT0(mult(m,n)))) exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT0(n)) -> BIT0#(mult(m,n)) exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT0(n)) -> mult#(m,n) exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) -> mult#(BIT0(m),BIT1(n)) -> plus#(BIT0(m),BIT0(BIT0(mult(m,n)))) exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) -> mult#(BIT0(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) -> mult#(BIT0(m),BIT1(n)) -> BIT0#(mult(m,n)) exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) -> mult#(BIT0(m),BIT1(n)) -> mult#(m,n) exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) -> mult#(BIT0(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) -> mult#(BIT0(m),BIT0(n)) -> BIT0#(mult(m,n)) exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) -> mult#(BIT0(m),BIT0(n)) -> mult#(m,n) exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) -> mult#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(mult(m,n)) exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) -> mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) exp#(BIT0(m),BIT0(n)) -> exp#(BIT0(m),n) -> exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) exp#(BIT0(m),BIT0(n)) -> exp#(BIT0(m),n) -> exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) exp#(BIT0(m),BIT0(n)) -> exp#(BIT0(m),n) -> exp#(BIT1(m),BIT1(n)) -> exp#(BIT1(m),n) exp#(BIT0(m),BIT0(n)) -> exp#(BIT0(m),n) -> exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp#(BIT0(m),BIT0(n)) -> exp#(BIT0(m),n) -> exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) exp#(BIT0(m),BIT0(n)) -> exp#(BIT0(m),n) -> exp#(BIT0(m),BIT1(n)) -> exp#(BIT0(m),n) exp#(BIT0(m),BIT0(n)) -> exp#(BIT0(m),n) -> exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) exp#(BIT0(m),BIT0(n)) -> exp#(BIT0(m),n) -> exp#(BIT1(m),BIT0(n)) -> exp#(BIT1(m),n) exp#(BIT0(m),BIT0(n)) -> exp#(BIT0(m),n) -> exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) exp#(BIT0(m),BIT0(n)) -> exp#(BIT0(m),n) -> exp#(BIT0(m),BIT0(n)) -> exp#(BIT0(m),n) exp#(BIT0(m),BIT0(n)) -> exp#(BIT0(m),n) -> exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) exp#(BIT0(m),BIT0(n)) -> exp#(BIT0(m),n) -> exp#(0(),BIT0(n)) -> exp#(0(),n) exp#(BIT0(m),BIT0(n)) -> exp#(BIT0(m),n) -> exp#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(exp(m,n)) exp#(BIT0(m),BIT0(n)) -> exp#(BIT0(m),n) -> exp#(NUMERAL(m),NUMERAL(n)) -> exp#(m,n) exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT1(n)) -> plus#(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT1(n)) -> plus#(BIT1(m),BIT0(n)) exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(n) exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(mult(m,n)) exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT1(n)) -> mult#(m,n) exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT0(n)) -> plus#(BIT0(n),BIT0(BIT0(mult(m,n)))) exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT0(n)) -> BIT0#(mult(m,n)) exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) -> mult#(BIT1(m),BIT0(n)) -> mult#(m,n) exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) -> mult#(BIT0(m),BIT1(n)) -> plus#(BIT0(m),BIT0(BIT0(mult(m,n)))) exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) -> mult#(BIT0(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) -> mult#(BIT0(m),BIT1(n)) -> BIT0#(mult(m,n)) exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) -> mult#(BIT0(m),BIT1(n)) -> mult#(m,n) exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) -> mult#(BIT0(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) -> mult#(BIT0(m),BIT0(n)) -> BIT0#(mult(m,n)) exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) -> mult#(BIT0(m),BIT0(n)) -> mult#(m,n) exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) -> mult#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(mult(m,n)) exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) -> mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) exp#(NUMERAL(m),NUMERAL(n)) -> exp#(m,n) -> exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) exp#(NUMERAL(m),NUMERAL(n)) -> exp#(m,n) -> exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) exp#(NUMERAL(m),NUMERAL(n)) -> exp#(m,n) -> exp#(BIT1(m),BIT1(n)) -> exp#(BIT1(m),n) exp#(NUMERAL(m),NUMERAL(n)) -> exp#(m,n) -> exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp#(NUMERAL(m),NUMERAL(n)) -> exp#(m,n) -> exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) exp#(NUMERAL(m),NUMERAL(n)) -> exp#(m,n) -> exp#(BIT0(m),BIT1(n)) -> exp#(BIT0(m),n) exp#(NUMERAL(m),NUMERAL(n)) -> exp#(m,n) -> exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) exp#(NUMERAL(m),NUMERAL(n)) -> exp#(m,n) -> exp#(BIT1(m),BIT0(n)) -> exp#(BIT1(m),n) exp#(NUMERAL(m),NUMERAL(n)) -> exp#(m,n) -> exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) exp#(NUMERAL(m),NUMERAL(n)) -> exp#(m,n) -> exp#(BIT0(m),BIT0(n)) -> exp#(BIT0(m),n) exp#(NUMERAL(m),NUMERAL(n)) -> exp#(m,n) -> exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) exp#(NUMERAL(m),NUMERAL(n)) -> exp#(m,n) -> exp#(0(),BIT0(n)) -> exp#(0(),n) exp#(NUMERAL(m),NUMERAL(n)) -> exp#(m,n) -> exp#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(exp(m,n)) exp#(NUMERAL(m),NUMERAL(n)) -> exp#(m,n) -> exp#(NUMERAL(m),NUMERAL(n)) -> exp#(m,n) exp#(0(),BIT0(n)) -> exp#(0(),n) -> exp#(BIT1(m),BIT1(n)) -> mult#(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) exp#(0(),BIT0(n)) -> exp#(0(),n) -> exp#(BIT1(m),BIT1(n)) -> mult#(BIT1(m),exp(BIT1(m),n)) exp#(0(),BIT0(n)) -> exp#(0(),n) -> exp#(BIT1(m),BIT1(n)) -> exp#(BIT1(m),n) exp#(0(),BIT0(n)) -> exp#(0(),n) -> exp#(BIT0(m),BIT1(n)) -> mult#(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp#(0(),BIT0(n)) -> exp#(0(),n) -> exp#(BIT0(m),BIT1(n)) -> mult#(BIT0(m),exp(BIT0(m),n)) exp#(0(),BIT0(n)) -> exp#(0(),n) -> exp#(BIT0(m),BIT1(n)) -> exp#(BIT0(m),n) exp#(0(),BIT0(n)) -> exp#(0(),n) -> exp#(BIT1(m),BIT0(n)) -> mult#(exp(BIT1(m),n),exp(BIT1(m),n)) exp#(0(),BIT0(n)) -> exp#(0(),n) -> exp#(BIT1(m),BIT0(n)) -> exp#(BIT1(m),n) exp#(0(),BIT0(n)) -> exp#(0(),n) -> exp#(BIT0(m),BIT0(n)) -> mult#(exp(BIT0(m),n),exp(BIT0(m),n)) exp#(0(),BIT0(n)) -> exp#(0(),n) -> exp#(BIT0(m),BIT0(n)) -> exp#(BIT0(m),n) exp#(0(),BIT0(n)) -> exp#(0(),n) -> exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) exp#(0(),BIT0(n)) -> exp#(0(),n) -> exp#(0(),BIT0(n)) -> exp#(0(),n) exp#(0(),BIT0(n)) -> exp#(0(),n) -> exp#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(exp(m,n)) exp#(0(),BIT0(n)) -> exp#(0(),n) -> exp#(NUMERAL(m),NUMERAL(n)) -> exp#(m,n) exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) -> mult#(BIT1(m),BIT1(n)) -> plus#(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) -> mult#(BIT1(m),BIT1(n)) -> plus#(BIT1(m),BIT0(n)) exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(n) exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(mult(m,n)) exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) -> mult#(BIT1(m),BIT1(n)) -> mult#(m,n) exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) -> mult#(BIT1(m),BIT0(n)) -> plus#(BIT0(n),BIT0(BIT0(mult(m,n)))) exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) -> mult#(BIT1(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) -> mult#(BIT1(m),BIT0(n)) -> BIT0#(mult(m,n)) exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) -> mult#(BIT1(m),BIT0(n)) -> mult#(m,n) exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) -> mult#(BIT0(m),BIT1(n)) -> plus#(BIT0(m),BIT0(BIT0(mult(m,n)))) exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) -> mult#(BIT0(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) -> mult#(BIT0(m),BIT1(n)) -> BIT0#(mult(m,n)) exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) -> mult#(BIT0(m),BIT1(n)) -> mult#(m,n) exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) -> mult#(BIT0(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) -> mult#(BIT0(m),BIT0(n)) -> BIT0#(mult(m,n)) exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) -> mult#(BIT0(m),BIT0(n)) -> mult#(m,n) exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) -> mult#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(mult(m,n)) exp#(0(),BIT0(n)) -> mult#(exp(0(),n),exp(0(),n)) -> mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) mult#(BIT1(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> plus#(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) mult#(BIT1(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> plus#(BIT1(m),BIT0(n)) mult#(BIT1(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(n) mult#(BIT1(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) mult#(BIT1(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(mult(m,n)) mult#(BIT1(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> mult#(m,n) mult#(BIT1(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT0(n)) -> plus#(BIT0(n),BIT0(BIT0(mult(m,n)))) mult#(BIT1(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) mult#(BIT1(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT0(n)) -> BIT0#(mult(m,n)) mult#(BIT1(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT0(n)) -> mult#(m,n) mult#(BIT1(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT1(n)) -> plus#(BIT0(m),BIT0(BIT0(mult(m,n)))) mult#(BIT1(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) mult#(BIT1(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT1(n)) -> BIT0#(mult(m,n)) mult#(BIT1(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT1(n)) -> mult#(m,n) mult#(BIT1(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) mult#(BIT1(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT0(n)) -> BIT0#(mult(m,n)) mult#(BIT1(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT0(n)) -> mult#(m,n) mult#(BIT1(m),BIT1(n)) -> mult#(m,n) -> mult#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(mult(m,n)) mult#(BIT1(m),BIT1(n)) -> mult#(m,n) -> mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) mult#(BIT1(m),BIT1(n)) -> plus#(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) -> plus#(BIT1(m),BIT1(n)) -> BIT0#(SUC(plus(m,n))) mult#(BIT1(m),BIT1(n)) -> plus#(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) -> plus#(BIT1(m),BIT1(n)) -> SUC#(plus(m,n)) mult#(BIT1(m),BIT1(n)) -> plus#(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) -> plus#(BIT1(m),BIT1(n)) -> plus#(m,n) mult#(BIT1(m),BIT1(n)) -> plus#(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) -> plus#(BIT1(m),BIT0(n)) -> plus#(m,n) mult#(BIT1(m),BIT1(n)) -> plus#(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) -> plus#(BIT0(m),BIT1(n)) -> plus#(m,n) mult#(BIT1(m),BIT1(n)) -> plus#(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) -> plus#(BIT0(m),BIT0(n)) -> BIT0#(plus(m,n)) mult#(BIT1(m),BIT1(n)) -> plus#(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) -> plus#(BIT0(m),BIT0(n)) -> plus#(m,n) mult#(BIT1(m),BIT1(n)) -> plus#(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) -> plus#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(plus(m,n)) mult#(BIT1(m),BIT1(n)) -> plus#(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) -> plus#(NUMERAL(m),NUMERAL(n)) -> plus#(m,n) mult#(BIT1(m),BIT1(n)) -> plus#(BIT1(m),BIT0(n)) -> plus#(BIT1(m),BIT1(n)) -> BIT0#(SUC(plus(m,n))) mult#(BIT1(m),BIT1(n)) -> plus#(BIT1(m),BIT0(n)) -> plus#(BIT1(m),BIT1(n)) -> SUC#(plus(m,n)) mult#(BIT1(m),BIT1(n)) -> plus#(BIT1(m),BIT0(n)) -> plus#(BIT1(m),BIT1(n)) -> plus#(m,n) mult#(BIT1(m),BIT1(n)) -> plus#(BIT1(m),BIT0(n)) -> plus#(BIT1(m),BIT0(n)) -> plus#(m,n) mult#(BIT1(m),BIT1(n)) -> plus#(BIT1(m),BIT0(n)) -> plus#(BIT0(m),BIT1(n)) -> plus#(m,n) mult#(BIT1(m),BIT1(n)) -> plus#(BIT1(m),BIT0(n)) -> plus#(BIT0(m),BIT0(n)) -> BIT0#(plus(m,n)) mult#(BIT1(m),BIT1(n)) -> plus#(BIT1(m),BIT0(n)) -> plus#(BIT0(m),BIT0(n)) -> plus#(m,n) mult#(BIT1(m),BIT1(n)) -> plus#(BIT1(m),BIT0(n)) -> plus#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(plus(m,n)) mult#(BIT1(m),BIT1(n)) -> plus#(BIT1(m),BIT0(n)) -> plus#(NUMERAL(m),NUMERAL(n)) -> plus#(m,n) mult#(BIT1(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> plus#(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) mult#(BIT1(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> plus#(BIT1(m),BIT0(n)) mult#(BIT1(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(n) mult#(BIT1(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) mult#(BIT1(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(mult(m,n)) mult#(BIT1(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> mult#(m,n) mult#(BIT1(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT0(n)) -> plus#(BIT0(n),BIT0(BIT0(mult(m,n)))) mult#(BIT1(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) mult#(BIT1(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT0(n)) -> BIT0#(mult(m,n)) mult#(BIT1(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT0(n)) -> mult#(m,n) mult#(BIT1(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT1(n)) -> plus#(BIT0(m),BIT0(BIT0(mult(m,n)))) mult#(BIT1(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) mult#(BIT1(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT1(n)) -> BIT0#(mult(m,n)) mult#(BIT1(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT1(n)) -> mult#(m,n) mult#(BIT1(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) mult#(BIT1(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT0(n)) -> BIT0#(mult(m,n)) mult#(BIT1(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT0(n)) -> mult#(m,n) mult#(BIT1(m),BIT0(n)) -> mult#(m,n) -> mult#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(mult(m,n)) mult#(BIT1(m),BIT0(n)) -> mult#(m,n) -> mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) mult#(BIT1(m),BIT0(n)) -> plus#(BIT0(n),BIT0(BIT0(mult(m,n)))) -> plus#(BIT1(m),BIT1(n)) -> BIT0#(SUC(plus(m,n))) mult#(BIT1(m),BIT0(n)) -> plus#(BIT0(n),BIT0(BIT0(mult(m,n)))) -> plus#(BIT1(m),BIT1(n)) -> SUC#(plus(m,n)) mult#(BIT1(m),BIT0(n)) -> plus#(BIT0(n),BIT0(BIT0(mult(m,n)))) -> plus#(BIT1(m),BIT1(n)) -> plus#(m,n) mult#(BIT1(m),BIT0(n)) -> plus#(BIT0(n),BIT0(BIT0(mult(m,n)))) -> plus#(BIT1(m),BIT0(n)) -> plus#(m,n) mult#(BIT1(m),BIT0(n)) -> plus#(BIT0(n),BIT0(BIT0(mult(m,n)))) -> plus#(BIT0(m),BIT1(n)) -> plus#(m,n) mult#(BIT1(m),BIT0(n)) -> plus#(BIT0(n),BIT0(BIT0(mult(m,n)))) -> plus#(BIT0(m),BIT0(n)) -> BIT0#(plus(m,n)) mult#(BIT1(m),BIT0(n)) -> plus#(BIT0(n),BIT0(BIT0(mult(m,n)))) -> plus#(BIT0(m),BIT0(n)) -> plus#(m,n) mult#(BIT1(m),BIT0(n)) -> plus#(BIT0(n),BIT0(BIT0(mult(m,n)))) -> plus#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(plus(m,n)) mult#(BIT1(m),BIT0(n)) -> plus#(BIT0(n),BIT0(BIT0(mult(m,n)))) -> plus#(NUMERAL(m),NUMERAL(n)) -> plus#(m,n) mult#(BIT0(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> plus#(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) mult#(BIT0(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> plus#(BIT1(m),BIT0(n)) mult#(BIT0(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(n) mult#(BIT0(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) mult#(BIT0(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(mult(m,n)) mult#(BIT0(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> mult#(m,n) mult#(BIT0(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT0(n)) -> plus#(BIT0(n),BIT0(BIT0(mult(m,n)))) mult#(BIT0(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) mult#(BIT0(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT0(n)) -> BIT0#(mult(m,n)) mult#(BIT0(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT0(n)) -> mult#(m,n) mult#(BIT0(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT1(n)) -> plus#(BIT0(m),BIT0(BIT0(mult(m,n)))) mult#(BIT0(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) mult#(BIT0(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT1(n)) -> BIT0#(mult(m,n)) mult#(BIT0(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT1(n)) -> mult#(m,n) mult#(BIT0(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) mult#(BIT0(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT0(n)) -> BIT0#(mult(m,n)) mult#(BIT0(m),BIT1(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT0(n)) -> mult#(m,n) mult#(BIT0(m),BIT1(n)) -> mult#(m,n) -> mult#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(mult(m,n)) mult#(BIT0(m),BIT1(n)) -> mult#(m,n) -> mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) mult#(BIT0(m),BIT1(n)) -> plus#(BIT0(m),BIT0(BIT0(mult(m,n)))) -> plus#(BIT1(m),BIT1(n)) -> BIT0#(SUC(plus(m,n))) mult#(BIT0(m),BIT1(n)) -> plus#(BIT0(m),BIT0(BIT0(mult(m,n)))) -> plus#(BIT1(m),BIT1(n)) -> SUC#(plus(m,n)) mult#(BIT0(m),BIT1(n)) -> plus#(BIT0(m),BIT0(BIT0(mult(m,n)))) -> plus#(BIT1(m),BIT1(n)) -> plus#(m,n) mult#(BIT0(m),BIT1(n)) -> plus#(BIT0(m),BIT0(BIT0(mult(m,n)))) -> plus#(BIT1(m),BIT0(n)) -> plus#(m,n) mult#(BIT0(m),BIT1(n)) -> plus#(BIT0(m),BIT0(BIT0(mult(m,n)))) -> plus#(BIT0(m),BIT1(n)) -> plus#(m,n) mult#(BIT0(m),BIT1(n)) -> plus#(BIT0(m),BIT0(BIT0(mult(m,n)))) -> plus#(BIT0(m),BIT0(n)) -> BIT0#(plus(m,n)) mult#(BIT0(m),BIT1(n)) -> plus#(BIT0(m),BIT0(BIT0(mult(m,n)))) -> plus#(BIT0(m),BIT0(n)) -> plus#(m,n) mult#(BIT0(m),BIT1(n)) -> plus#(BIT0(m),BIT0(BIT0(mult(m,n)))) -> plus#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(plus(m,n)) mult#(BIT0(m),BIT1(n)) -> plus#(BIT0(m),BIT0(BIT0(mult(m,n)))) -> plus#(NUMERAL(m),NUMERAL(n)) -> plus#(m,n) mult#(BIT0(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> plus#(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) mult#(BIT0(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> plus#(BIT1(m),BIT0(n)) mult#(BIT0(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(n) mult#(BIT0(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) mult#(BIT0(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(mult(m,n)) mult#(BIT0(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> mult#(m,n) mult#(BIT0(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT0(n)) -> plus#(BIT0(n),BIT0(BIT0(mult(m,n)))) mult#(BIT0(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) mult#(BIT0(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT0(n)) -> BIT0#(mult(m,n)) mult#(BIT0(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT0(n)) -> mult#(m,n) mult#(BIT0(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT1(n)) -> plus#(BIT0(m),BIT0(BIT0(mult(m,n)))) mult#(BIT0(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) mult#(BIT0(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT1(n)) -> BIT0#(mult(m,n)) mult#(BIT0(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT1(n)) -> mult#(m,n) mult#(BIT0(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) mult#(BIT0(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT0(n)) -> BIT0#(mult(m,n)) mult#(BIT0(m),BIT0(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT0(n)) -> mult#(m,n) mult#(BIT0(m),BIT0(n)) -> mult#(m,n) -> mult#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(mult(m,n)) mult#(BIT0(m),BIT0(n)) -> mult#(m,n) -> mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> plus#(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> plus#(BIT1(m),BIT0(n)) mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(n) mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> BIT0#(mult(m,n)) mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT1(n)) -> mult#(m,n) mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT0(n)) -> plus#(BIT0(n),BIT0(BIT0(mult(m,n)))) mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT0(n)) -> BIT0#(mult(m,n)) mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) -> mult#(BIT1(m),BIT0(n)) -> mult#(m,n) mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT1(n)) -> plus#(BIT0(m),BIT0(BIT0(mult(m,n)))) mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT1(n)) -> BIT0#(BIT0(mult(m,n))) mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT1(n)) -> BIT0#(mult(m,n)) mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT1(n)) -> mult#(m,n) mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT0(n)) -> BIT0#(BIT0(mult(m,n))) mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT0(n)) -> BIT0#(mult(m,n)) mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) -> mult#(BIT0(m),BIT0(n)) -> mult#(m,n) mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) -> mult#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(mult(m,n)) mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) -> mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) plus#(BIT1(m),BIT1(n)) -> plus#(m,n) -> plus#(BIT1(m),BIT1(n)) -> BIT0#(SUC(plus(m,n))) plus#(BIT1(m),BIT1(n)) -> plus#(m,n) -> plus#(BIT1(m),BIT1(n)) -> SUC#(plus(m,n)) plus#(BIT1(m),BIT1(n)) -> plus#(m,n) -> plus#(BIT1(m),BIT1(n)) -> plus#(m,n) plus#(BIT1(m),BIT1(n)) -> plus#(m,n) -> plus#(BIT1(m),BIT0(n)) -> plus#(m,n) plus#(BIT1(m),BIT1(n)) -> plus#(m,n) -> plus#(BIT0(m),BIT1(n)) -> plus#(m,n) plus#(BIT1(m),BIT1(n)) -> plus#(m,n) -> plus#(BIT0(m),BIT0(n)) -> BIT0#(plus(m,n)) plus#(BIT1(m),BIT1(n)) -> plus#(m,n) -> plus#(BIT0(m),BIT0(n)) -> plus#(m,n) plus#(BIT1(m),BIT1(n)) -> plus#(m,n) -> plus#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(plus(m,n)) plus#(BIT1(m),BIT1(n)) -> plus#(m,n) -> plus#(NUMERAL(m),NUMERAL(n)) -> plus#(m,n) plus#(BIT1(m),BIT1(n)) -> SUC#(plus(m,n)) -> SUC#(BIT1(n)) -> BIT0#(SUC(n)) plus#(BIT1(m),BIT1(n)) -> SUC#(plus(m,n)) -> SUC#(BIT1(n)) -> SUC#(n) plus#(BIT1(m),BIT1(n)) -> SUC#(plus(m,n)) -> SUC#(NUMERAL(n)) -> NUMERAL#(SUC(n)) plus#(BIT1(m),BIT1(n)) -> SUC#(plus(m,n)) -> SUC#(NUMERAL(n)) -> SUC#(n) plus#(BIT1(m),BIT0(n)) -> plus#(m,n) -> plus#(BIT1(m),BIT1(n)) -> BIT0#(SUC(plus(m,n))) plus#(BIT1(m),BIT0(n)) -> plus#(m,n) -> plus#(BIT1(m),BIT1(n)) -> SUC#(plus(m,n)) plus#(BIT1(m),BIT0(n)) -> plus#(m,n) -> plus#(BIT1(m),BIT1(n)) -> plus#(m,n) plus#(BIT1(m),BIT0(n)) -> plus#(m,n) -> plus#(BIT1(m),BIT0(n)) -> plus#(m,n) plus#(BIT1(m),BIT0(n)) -> plus#(m,n) -> plus#(BIT0(m),BIT1(n)) -> plus#(m,n) plus#(BIT1(m),BIT0(n)) -> plus#(m,n) -> plus#(BIT0(m),BIT0(n)) -> BIT0#(plus(m,n)) plus#(BIT1(m),BIT0(n)) -> plus#(m,n) -> plus#(BIT0(m),BIT0(n)) -> plus#(m,n) plus#(BIT1(m),BIT0(n)) -> plus#(m,n) -> plus#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(plus(m,n)) plus#(BIT1(m),BIT0(n)) -> plus#(m,n) -> plus#(NUMERAL(m),NUMERAL(n)) -> plus#(m,n) plus#(BIT0(m),BIT1(n)) -> plus#(m,n) -> plus#(BIT1(m),BIT1(n)) -> BIT0#(SUC(plus(m,n))) plus#(BIT0(m),BIT1(n)) -> plus#(m,n) -> plus#(BIT1(m),BIT1(n)) -> SUC#(plus(m,n)) plus#(BIT0(m),BIT1(n)) -> plus#(m,n) -> plus#(BIT1(m),BIT1(n)) -> plus#(m,n) plus#(BIT0(m),BIT1(n)) -> plus#(m,n) -> plus#(BIT1(m),BIT0(n)) -> plus#(m,n) plus#(BIT0(m),BIT1(n)) -> plus#(m,n) -> plus#(BIT0(m),BIT1(n)) -> plus#(m,n) plus#(BIT0(m),BIT1(n)) -> plus#(m,n) -> plus#(BIT0(m),BIT0(n)) -> BIT0#(plus(m,n)) plus#(BIT0(m),BIT1(n)) -> plus#(m,n) -> plus#(BIT0(m),BIT0(n)) -> plus#(m,n) plus#(BIT0(m),BIT1(n)) -> plus#(m,n) -> plus#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(plus(m,n)) plus#(BIT0(m),BIT1(n)) -> plus#(m,n) -> plus#(NUMERAL(m),NUMERAL(n)) -> plus#(m,n) plus#(BIT0(m),BIT0(n)) -> plus#(m,n) -> plus#(BIT1(m),BIT1(n)) -> BIT0#(SUC(plus(m,n))) plus#(BIT0(m),BIT0(n)) -> plus#(m,n) -> plus#(BIT1(m),BIT1(n)) -> SUC#(plus(m,n)) plus#(BIT0(m),BIT0(n)) -> plus#(m,n) -> plus#(BIT1(m),BIT1(n)) -> plus#(m,n) plus#(BIT0(m),BIT0(n)) -> plus#(m,n) -> plus#(BIT1(m),BIT0(n)) -> plus#(m,n) plus#(BIT0(m),BIT0(n)) -> plus#(m,n) -> plus#(BIT0(m),BIT1(n)) -> plus#(m,n) plus#(BIT0(m),BIT0(n)) -> plus#(m,n) -> plus#(BIT0(m),BIT0(n)) -> BIT0#(plus(m,n)) plus#(BIT0(m),BIT0(n)) -> plus#(m,n) -> plus#(BIT0(m),BIT0(n)) -> plus#(m,n) plus#(BIT0(m),BIT0(n)) -> plus#(m,n) -> plus#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(plus(m,n)) plus#(BIT0(m),BIT0(n)) -> plus#(m,n) -> plus#(NUMERAL(m),NUMERAL(n)) -> plus#(m,n) plus#(NUMERAL(m),NUMERAL(n)) -> plus#(m,n) -> plus#(BIT1(m),BIT1(n)) -> BIT0#(SUC(plus(m,n))) plus#(NUMERAL(m),NUMERAL(n)) -> plus#(m,n) -> plus#(BIT1(m),BIT1(n)) -> SUC#(plus(m,n)) plus#(NUMERAL(m),NUMERAL(n)) -> plus#(m,n) -> plus#(BIT1(m),BIT1(n)) -> plus#(m,n) plus#(NUMERAL(m),NUMERAL(n)) -> plus#(m,n) -> plus#(BIT1(m),BIT0(n)) -> plus#(m,n) plus#(NUMERAL(m),NUMERAL(n)) -> plus#(m,n) -> plus#(BIT0(m),BIT1(n)) -> plus#(m,n) plus#(NUMERAL(m),NUMERAL(n)) -> plus#(m,n) -> plus#(BIT0(m),BIT0(n)) -> BIT0#(plus(m,n)) plus#(NUMERAL(m),NUMERAL(n)) -> plus#(m,n) -> plus#(BIT0(m),BIT0(n)) -> plus#(m,n) plus#(NUMERAL(m),NUMERAL(n)) -> plus#(m,n) -> plus#(NUMERAL(m),NUMERAL(n)) -> NUMERAL#(plus(m,n)) plus#(NUMERAL(m),NUMERAL(n)) -> plus#(m,n) -> plus#(NUMERAL(m),NUMERAL(n)) -> plus#(m,n) eq#(BIT1(m),BIT1(n)) -> eq#(m,n) -> eq#(BIT1(m),BIT1(n)) -> eq#(m,n) eq#(BIT1(m),BIT1(n)) -> eq#(m,n) -> eq#(BIT0(m),BIT0(n)) -> eq#(m,n) eq#(BIT1(m),BIT1(n)) -> eq#(m,n) -> eq#(0(),BIT0(n)) -> eq#(0(),n) eq#(BIT1(m),BIT1(n)) -> eq#(m,n) -> eq#(BIT0(n),0()) -> eq#(n,0()) eq#(BIT1(m),BIT1(n)) -> eq#(m,n) -> eq#(NUMERAL(m),NUMERAL(n)) -> eq#(m,n) eq#(BIT0(m),BIT0(n)) -> eq#(m,n) -> eq#(BIT1(m),BIT1(n)) -> eq#(m,n) eq#(BIT0(m),BIT0(n)) -> eq#(m,n) -> eq#(BIT0(m),BIT0(n)) -> eq#(m,n) eq#(BIT0(m),BIT0(n)) -> eq#(m,n) -> eq#(0(),BIT0(n)) -> eq#(0(),n) eq#(BIT0(m),BIT0(n)) -> eq#(m,n) -> eq#(BIT0(n),0()) -> eq#(n,0()) eq#(BIT0(m),BIT0(n)) -> eq#(m,n) -> eq#(NUMERAL(m),NUMERAL(n)) -> eq#(m,n) eq#(BIT0(n),0()) -> eq#(n,0()) -> eq#(BIT1(m),BIT1(n)) -> eq#(m,n) eq#(BIT0(n),0()) -> eq#(n,0()) -> eq#(BIT0(m),BIT0(n)) -> eq#(m,n) eq#(BIT0(n),0()) -> eq#(n,0()) -> eq#(0(),BIT0(n)) -> eq#(0(),n) eq#(BIT0(n),0()) -> eq#(n,0()) -> eq#(BIT0(n),0()) -> eq#(n,0()) eq#(BIT0(n),0()) -> eq#(n,0()) -> eq#(NUMERAL(m),NUMERAL(n)) -> eq#(m,n) eq#(NUMERAL(m),NUMERAL(n)) -> eq#(m,n) -> eq#(BIT1(m),BIT1(n)) -> eq#(m,n) eq#(NUMERAL(m),NUMERAL(n)) -> eq#(m,n) -> eq#(BIT0(m),BIT0(n)) -> eq#(m,n) eq#(NUMERAL(m),NUMERAL(n)) -> eq#(m,n) -> eq#(0(),BIT0(n)) -> eq#(0(),n) eq#(NUMERAL(m),NUMERAL(n)) -> eq#(m,n) -> eq#(BIT0(n),0()) -> eq#(n,0()) eq#(NUMERAL(m),NUMERAL(n)) -> eq#(m,n) -> eq#(NUMERAL(m),NUMERAL(n)) -> eq#(m,n) eq#(0(),BIT0(n)) -> eq#(0(),n) -> eq#(BIT1(m),BIT1(n)) -> eq#(m,n) eq#(0(),BIT0(n)) -> eq#(0(),n) -> eq#(BIT0(m),BIT0(n)) -> eq#(m,n) eq#(0(),BIT0(n)) -> eq#(0(),n) -> eq#(0(),BIT0(n)) -> eq#(0(),n) eq#(0(),BIT0(n)) -> eq#(0(),n) -> eq#(BIT0(n),0()) -> eq#(n,0()) eq#(0(),BIT0(n)) -> eq#(0(),n) -> eq#(NUMERAL(m),NUMERAL(n)) -> eq#(m,n) PRE#(BIT0(n)) -> eq#(n,0()) -> eq#(BIT1(m),BIT1(n)) -> eq#(m,n) PRE#(BIT0(n)) -> eq#(n,0()) -> eq#(BIT0(m),BIT0(n)) -> eq#(m,n) PRE#(BIT0(n)) -> eq#(n,0()) -> eq#(0(),BIT0(n)) -> eq#(0(),n) PRE#(BIT0(n)) -> eq#(n,0()) -> eq#(BIT0(n),0()) -> eq#(n,0()) PRE#(BIT0(n)) -> eq#(n,0()) -> eq#(NUMERAL(m),NUMERAL(n)) -> eq#(m,n) PRE#(BIT0(n)) -> PRE#(n) -> PRE#(BIT1(n)) -> BIT0#(n) PRE#(BIT0(n)) -> PRE#(n) -> PRE#(BIT0(n)) -> eq#(n,0()) PRE#(BIT0(n)) -> PRE#(n) -> PRE#(BIT0(n)) -> PRE#(n) PRE#(BIT0(n)) -> PRE#(n) -> PRE#(NUMERAL(n)) -> NUMERAL#(PRE(n)) PRE#(BIT0(n)) -> PRE#(n) -> PRE#(NUMERAL(n)) -> PRE#(n) PRE#(NUMERAL(n)) -> PRE#(n) -> PRE#(BIT1(n)) -> BIT0#(n) PRE#(NUMERAL(n)) -> PRE#(n) -> PRE#(BIT0(n)) -> eq#(n,0()) PRE#(NUMERAL(n)) -> PRE#(n) -> PRE#(BIT0(n)) -> PRE#(n) PRE#(NUMERAL(n)) -> PRE#(n) -> PRE#(NUMERAL(n)) -> NUMERAL#(PRE(n)) PRE#(NUMERAL(n)) -> PRE#(n) -> PRE#(NUMERAL(n)) -> PRE#(n) SUC#(BIT1(n)) -> SUC#(n) -> SUC#(BIT1(n)) -> BIT0#(SUC(n)) SUC#(BIT1(n)) -> SUC#(n) -> SUC#(BIT1(n)) -> SUC#(n) SUC#(BIT1(n)) -> SUC#(n) -> SUC#(NUMERAL(n)) -> NUMERAL#(SUC(n)) SUC#(BIT1(n)) -> SUC#(n) -> SUC#(NUMERAL(n)) -> SUC#(n) SUC#(NUMERAL(n)) -> SUC#(n) -> SUC#(BIT1(n)) -> BIT0#(SUC(n)) SUC#(NUMERAL(n)) -> SUC#(n) -> SUC#(BIT1(n)) -> SUC#(n) SUC#(NUMERAL(n)) -> SUC#(n) -> SUC#(NUMERAL(n)) -> NUMERAL#(SUC(n)) SUC#(NUMERAL(n)) -> SUC#(n) -> SUC#(NUMERAL(n)) -> SUC#(n) SCC Processor: #sccs: 11 #rules: 56 #arcs: 657/8649 DPs: exp#(BIT1(m),BIT1(n)) -> exp#(BIT1(m),n) exp#(NUMERAL(m),NUMERAL(n)) -> exp#(m,n) exp#(0(),BIT0(n)) -> exp#(0(),n) exp#(BIT0(m),BIT0(n)) -> exp#(BIT0(m),n) exp#(BIT1(m),BIT0(n)) -> exp#(BIT1(m),n) exp#(BIT0(m),BIT1(n)) -> exp#(BIT0(m),n) TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Subterm Criterion Processor: simple projection: pi(exp#) = 0 problem: DPs: exp#(BIT1(m),BIT1(n)) -> exp#(BIT1(m),n) exp#(0(),BIT0(n)) -> exp#(0(),n) exp#(BIT0(m),BIT0(n)) -> exp#(BIT0(m),n) exp#(BIT1(m),BIT0(n)) -> exp#(BIT1(m),n) exp#(BIT0(m),BIT1(n)) -> exp#(BIT0(m),n) TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Subterm Criterion Processor: simple projection: pi(exp#) = 1 problem: DPs: TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Qed DPs: mult#(NUMERAL(m),NUMERAL(n)) -> mult#(m,n) mult#(BIT0(m),BIT0(n)) -> mult#(m,n) mult#(BIT0(m),BIT1(n)) -> mult#(m,n) mult#(BIT1(m),BIT0(n)) -> mult#(m,n) mult#(BIT1(m),BIT1(n)) -> mult#(m,n) TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Subterm Criterion Processor: simple projection: pi(mult#) = 0 problem: DPs: TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Qed DPs: plus#(NUMERAL(m),NUMERAL(n)) -> plus#(m,n) plus#(BIT0(m),BIT0(n)) -> plus#(m,n) plus#(BIT0(m),BIT1(n)) -> plus#(m,n) plus#(BIT1(m),BIT0(n)) -> plus#(m,n) plus#(BIT1(m),BIT1(n)) -> plus#(m,n) TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Subterm Criterion Processor: simple projection: pi(plus#) = 0 problem: DPs: TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Qed DPs: SUC#(NUMERAL(n)) -> SUC#(n) SUC#(BIT1(n)) -> SUC#(n) TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Subterm Criterion Processor: simple projection: pi(SUC#) = 0 problem: DPs: TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Qed DPs: EVEN#(NUMERAL(n)) -> EVEN#(n) TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Subterm Criterion Processor: simple projection: pi(EVEN#) = 0 problem: DPs: TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Qed DPs: ODD#(NUMERAL(n)) -> ODD#(n) TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Subterm Criterion Processor: simple projection: pi(ODD#) = 0 problem: DPs: TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Qed DPs: gt#(BIT1(n),BIT1(m)) -> gt#(n,m) gt#(NUMERAL(n),NUMERAL(m)) -> gt#(n,m) gt#(BIT0(n),0()) -> gt#(n,0()) gt#(BIT0(n),BIT0(m)) -> gt#(n,m) gt#(BIT1(n),BIT0(m)) -> ge#(n,m) ge#(NUMERAL(n),NUMERAL(m)) -> ge#(n,m) ge#(0(),BIT0(n)) -> ge#(0(),n) ge#(BIT0(n),BIT0(m)) -> ge#(n,m) ge#(BIT1(n),BIT0(m)) -> ge#(n,m) ge#(BIT0(n),BIT1(m)) -> gt#(n,m) gt#(BIT0(n),BIT1(m)) -> gt#(n,m) ge#(BIT1(n),BIT1(m)) -> ge#(n,m) TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Subterm Criterion Processor: simple projection: pi(ge#) = 0 pi(gt#) = 0 problem: DPs: ge#(0(),BIT0(n)) -> ge#(0(),n) TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Subterm Criterion Processor: simple projection: pi(ge#) = 1 problem: DPs: TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Qed DPs: minus#(BIT1(m),BIT1(n)) -> minus#(m,n) minus#(NUMERAL(m),NUMERAL(n)) -> minus#(m,n) minus#(BIT0(m),BIT0(n)) -> minus#(m,n) minus#(BIT0(m),BIT1(n)) -> minus#(m,n) minus#(BIT1(m),BIT0(n)) -> minus#(m,n) TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Subterm Criterion Processor: simple projection: pi(minus#) = 0 problem: DPs: TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Qed DPs: le#(NUMERAL(m),NUMERAL(n)) -> le#(m,n) le#(BIT0(n),0()) -> le#(n,0()) le#(BIT0(m),BIT0(n)) -> le#(m,n) le#(BIT0(m),BIT1(n)) -> le#(m,n) le#(BIT1(m),BIT0(n)) -> lt#(m,n) lt#(NUMERAL(m),NUMERAL(n)) -> lt#(m,n) lt#(0(),BIT0(n)) -> lt#(0(),n) lt#(BIT0(m),BIT0(n)) -> lt#(m,n) lt#(BIT0(m),BIT1(n)) -> le#(m,n) le#(BIT1(m),BIT1(n)) -> le#(m,n) lt#(BIT1(m),BIT0(n)) -> lt#(m,n) lt#(BIT1(m),BIT1(n)) -> lt#(m,n) TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Subterm Criterion Processor: simple projection: pi(le#) = 0 pi(lt#) = 0 problem: DPs: lt#(0(),BIT0(n)) -> lt#(0(),n) TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Subterm Criterion Processor: simple projection: pi(lt#) = 1 problem: DPs: TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Qed DPs: PRE#(NUMERAL(n)) -> PRE#(n) PRE#(BIT0(n)) -> PRE#(n) TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Subterm Criterion Processor: simple projection: pi(PRE#) = 0 problem: DPs: TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Qed DPs: eq#(NUMERAL(m),NUMERAL(n)) -> eq#(m,n) eq#(BIT0(n),0()) -> eq#(n,0()) eq#(0(),BIT0(n)) -> eq#(0(),n) eq#(BIT0(m),BIT0(n)) -> eq#(m,n) eq#(BIT1(m),BIT1(n)) -> eq#(m,n) TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Subterm Criterion Processor: simple projection: pi(eq#) = 0 problem: DPs: eq#(0(),BIT0(n)) -> eq#(0(),n) TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Subterm Criterion Processor: simple projection: pi(eq#) = 1 problem: DPs: TRS: NUMERAL(0()) -> 0() BIT0(0()) -> 0() SUC(NUMERAL(n)) -> NUMERAL(SUC(n)) SUC(0()) -> BIT1(0()) SUC(BIT0(n)) -> BIT1(n) SUC(BIT1(n)) -> BIT0(SUC(n)) PRE(NUMERAL(n)) -> NUMERAL(PRE(n)) PRE(0()) -> 0() PRE(BIT0(n)) -> if(eq(n,0()),0(),BIT1(PRE(n))) PRE(BIT1(n)) -> BIT0(n) plus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(plus(m,n)) plus(0(),0()) -> 0() plus(0(),BIT0(n)) -> BIT0(n) plus(0(),BIT1(n)) -> BIT1(n) plus(BIT0(n),0()) -> BIT0(n) plus(BIT1(n),0()) -> BIT1(n) plus(BIT0(m),BIT0(n)) -> BIT0(plus(m,n)) plus(BIT0(m),BIT1(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT0(n)) -> BIT1(plus(m,n)) plus(BIT1(m),BIT1(n)) -> BIT0(SUC(plus(m,n))) mult(NUMERAL(m),NUMERAL(n)) -> NUMERAL(mult(m,n)) mult(0(),0()) -> 0() mult(0(),BIT0(n)) -> 0() mult(0(),BIT1(n)) -> 0() mult(BIT0(n),0()) -> 0() mult(BIT1(n),0()) -> 0() mult(BIT0(m),BIT0(n)) -> BIT0(BIT0(mult(m,n))) mult(BIT0(m),BIT1(n)) -> plus(BIT0(m),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT0(n)) -> plus(BIT0(n),BIT0(BIT0(mult(m,n)))) mult(BIT1(m),BIT1(n)) -> plus(plus(BIT1(m),BIT0(n)),BIT0(BIT0(mult(m,n)))) exp(NUMERAL(m),NUMERAL(n)) -> NUMERAL(exp(m,n)) exp(0(),0()) -> BIT1(0()) exp(BIT0(m),0()) -> BIT1(0()) exp(BIT1(m),0()) -> BIT1(0()) exp(0(),BIT0(n)) -> mult(exp(0(),n),exp(0(),n)) exp(BIT0(m),BIT0(n)) -> mult(exp(BIT0(m),n),exp(BIT0(m),n)) exp(BIT1(m),BIT0(n)) -> mult(exp(BIT1(m),n),exp(BIT1(m),n)) exp(0(),BIT1(n)) -> 0() exp(BIT0(m),BIT1(n)) -> mult(mult(BIT0(m),exp(BIT0(m),n)),exp(BIT0(m),n)) exp(BIT1(m),BIT1(n)) -> mult(mult(BIT1(m),exp(BIT1(m),n)),exp(BIT1(m),n)) EVEN(NUMERAL(n)) -> EVEN(n) EVEN(0()) -> T() EVEN(BIT0(n)) -> T() EVEN(BIT1(n)) -> F() ODD(NUMERAL(n)) -> ODD(n) ODD(0()) -> F() ODD(BIT0(n)) -> F() ODD(BIT1(n)) -> T() eq(NUMERAL(m),NUMERAL(n)) -> eq(m,n) eq(0(),0()) -> T() eq(BIT0(n),0()) -> eq(n,0()) eq(BIT1(n),0()) -> F() eq(0(),BIT0(n)) -> eq(0(),n) eq(0(),BIT1(n)) -> F() eq(BIT0(m),BIT0(n)) -> eq(m,n) eq(BIT0(m),BIT1(n)) -> F() eq(BIT1(m),BIT0(n)) -> F() eq(BIT1(m),BIT1(n)) -> eq(m,n) le(NUMERAL(m),NUMERAL(n)) -> le(m,n) le(0(),0()) -> T() le(BIT0(n),0()) -> le(n,0()) le(BIT1(n),0()) -> F() le(0(),BIT0(n)) -> T() le(0(),BIT1(n)) -> T() le(BIT0(m),BIT0(n)) -> le(m,n) le(BIT0(m),BIT1(n)) -> le(m,n) le(BIT1(m),BIT0(n)) -> lt(m,n) le(BIT1(m),BIT1(n)) -> le(m,n) lt(NUMERAL(m),NUMERAL(n)) -> lt(m,n) lt(0(),0()) -> F() lt(BIT0(n),0()) -> F() lt(BIT1(n),0()) -> F() lt(0(),BIT0(n)) -> lt(0(),n) lt(0(),BIT1(n)) -> T() lt(BIT0(m),BIT0(n)) -> lt(m,n) lt(BIT0(m),BIT1(n)) -> le(m,n) lt(BIT1(m),BIT0(n)) -> lt(m,n) lt(BIT1(m),BIT1(n)) -> lt(m,n) ge(NUMERAL(n),NUMERAL(m)) -> ge(n,m) ge(0(),0()) -> T() ge(0(),BIT0(n)) -> ge(0(),n) ge(0(),BIT1(n)) -> F() ge(BIT0(n),0()) -> T() ge(BIT1(n),0()) -> T() ge(BIT0(n),BIT0(m)) -> ge(n,m) ge(BIT1(n),BIT0(m)) -> ge(n,m) ge(BIT0(n),BIT1(m)) -> gt(n,m) ge(BIT1(n),BIT1(m)) -> ge(n,m) gt(NUMERAL(n),NUMERAL(m)) -> gt(n,m) gt(0(),0()) -> F() gt(0(),BIT0(n)) -> F() gt(0(),BIT1(n)) -> F() gt(BIT0(n),0()) -> gt(n,0()) gt(BIT1(n),0()) -> T() gt(BIT0(n),BIT0(m)) -> gt(n,m) gt(BIT1(n),BIT0(m)) -> ge(n,m) gt(BIT0(n),BIT1(m)) -> gt(n,m) gt(BIT1(n),BIT1(m)) -> gt(n,m) minus(NUMERAL(m),NUMERAL(n)) -> NUMERAL(minus(m,n)) minus(0(),0()) -> 0() minus(0(),BIT0(n)) -> 0() minus(0(),BIT1(n)) -> 0() minus(BIT0(n),0()) -> BIT0(n) minus(BIT1(n),0()) -> BIT1(n) minus(BIT0(m),BIT0(n)) -> BIT0(minus(m,n)) minus(BIT0(m),BIT1(n)) -> PRE(BIT0(minus(m,n))) minus(BIT1(m),BIT0(n)) -> if(le(n,m),BIT1(minus(m,n)),0()) minus(BIT1(m),BIT1(n)) -> BIT0(minus(m,n)) Qed