/export/starexec/sandbox/solver/bin/starexec_run_default /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files -------------------------------------------------------------------------------- YES Problem 1: (VAR I P V V1 V2 X X1 X2 Y Z) (RULES __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ) Problem 1: Dependency Pairs Processor: -> Pairs: __#(active(X1),X2) -> __#(X1,X2) __#(mark(X1),X2) -> __#(X1,X2) __#(X1,active(X2)) -> __#(X1,X2) __#(X1,mark(X2)) -> __#(X1,X2) ACTIVE(__(__(X,Y),Z)) -> __#(X,__(Y,Z)) ACTIVE(__(__(X,Y),Z)) -> __#(Y,Z) ACTIVE(__(__(X,Y),Z)) -> MARK(__(X,__(Y,Z))) ACTIVE(__(nil,X)) -> MARK(X) ACTIVE(__(X,nil)) -> MARK(X) ACTIVE(and(tt,X)) -> MARK(X) ACTIVE(isList(__(V1,V2))) -> AND(isList(V1),isList(V2)) ACTIVE(isList(__(V1,V2))) -> ISLIST(V1) ACTIVE(isList(__(V1,V2))) -> ISLIST(V2) ACTIVE(isList(__(V1,V2))) -> MARK(and(isList(V1),isList(V2))) ACTIVE(isList(nil)) -> MARK(tt) ACTIVE(isList(V)) -> ISNELIST(V) ACTIVE(isList(V)) -> MARK(isNeList(V)) ACTIVE(isNeList(__(V1,V2))) -> AND(isList(V1),isNeList(V2)) ACTIVE(isNeList(__(V1,V2))) -> AND(isNeList(V1),isList(V2)) ACTIVE(isNeList(__(V1,V2))) -> ISLIST(V1) ACTIVE(isNeList(__(V1,V2))) -> ISLIST(V2) ACTIVE(isNeList(__(V1,V2))) -> ISNELIST(V1) ACTIVE(isNeList(__(V1,V2))) -> ISNELIST(V2) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isList(V1),isNeList(V2))) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> ISQID(V) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> AND(isQid(I),isPal(P)) ACTIVE(isNePal(__(I,__(P,I)))) -> ISPAL(P) ACTIVE(isNePal(__(I,__(P,I)))) -> ISQID(I) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> ISQID(V) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(nil)) -> MARK(tt) ACTIVE(isPal(V)) -> ISNEPAL(V) ACTIVE(isPal(V)) -> MARK(isNePal(V)) ACTIVE(isQid(a)) -> MARK(tt) ACTIVE(isQid(e)) -> MARK(tt) ACTIVE(isQid(i)) -> MARK(tt) ACTIVE(isQid(o)) -> MARK(tt) ACTIVE(isQid(u)) -> MARK(tt) AND(active(X1),X2) -> AND(X1,X2) AND(mark(X1),X2) -> AND(X1,X2) AND(X1,active(X2)) -> AND(X1,X2) AND(X1,mark(X2)) -> AND(X1,X2) ISLIST(active(X)) -> ISLIST(X) ISLIST(mark(X)) -> ISLIST(X) ISNELIST(active(X)) -> ISNELIST(X) ISNELIST(mark(X)) -> ISNELIST(X) ISNEPAL(active(X)) -> ISNEPAL(X) ISNEPAL(mark(X)) -> ISNEPAL(X) ISPAL(active(X)) -> ISPAL(X) ISPAL(mark(X)) -> ISPAL(X) ISQID(active(X)) -> ISQID(X) ISQID(mark(X)) -> ISQID(X) MARK(__(X1,X2)) -> __#(mark(X1),mark(X2)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> AND(mark(X1),X2) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) Problem 1: SCC Processor: -> Pairs: __#(active(X1),X2) -> __#(X1,X2) __#(mark(X1),X2) -> __#(X1,X2) __#(X1,active(X2)) -> __#(X1,X2) __#(X1,mark(X2)) -> __#(X1,X2) ACTIVE(__(__(X,Y),Z)) -> __#(X,__(Y,Z)) ACTIVE(__(__(X,Y),Z)) -> __#(Y,Z) ACTIVE(__(__(X,Y),Z)) -> MARK(__(X,__(Y,Z))) ACTIVE(__(nil,X)) -> MARK(X) ACTIVE(__(X,nil)) -> MARK(X) ACTIVE(and(tt,X)) -> MARK(X) ACTIVE(isList(__(V1,V2))) -> AND(isList(V1),isList(V2)) ACTIVE(isList(__(V1,V2))) -> ISLIST(V1) ACTIVE(isList(__(V1,V2))) -> ISLIST(V2) ACTIVE(isList(__(V1,V2))) -> MARK(and(isList(V1),isList(V2))) ACTIVE(isList(nil)) -> MARK(tt) ACTIVE(isList(V)) -> ISNELIST(V) ACTIVE(isList(V)) -> MARK(isNeList(V)) ACTIVE(isNeList(__(V1,V2))) -> AND(isList(V1),isNeList(V2)) ACTIVE(isNeList(__(V1,V2))) -> AND(isNeList(V1),isList(V2)) ACTIVE(isNeList(__(V1,V2))) -> ISLIST(V1) ACTIVE(isNeList(__(V1,V2))) -> ISLIST(V2) ACTIVE(isNeList(__(V1,V2))) -> ISNELIST(V1) ACTIVE(isNeList(__(V1,V2))) -> ISNELIST(V2) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isList(V1),isNeList(V2))) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> ISQID(V) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> AND(isQid(I),isPal(P)) ACTIVE(isNePal(__(I,__(P,I)))) -> ISPAL(P) ACTIVE(isNePal(__(I,__(P,I)))) -> ISQID(I) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> ISQID(V) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(nil)) -> MARK(tt) ACTIVE(isPal(V)) -> ISNEPAL(V) ACTIVE(isPal(V)) -> MARK(isNePal(V)) ACTIVE(isQid(a)) -> MARK(tt) ACTIVE(isQid(e)) -> MARK(tt) ACTIVE(isQid(i)) -> MARK(tt) ACTIVE(isQid(o)) -> MARK(tt) ACTIVE(isQid(u)) -> MARK(tt) AND(active(X1),X2) -> AND(X1,X2) AND(mark(X1),X2) -> AND(X1,X2) AND(X1,active(X2)) -> AND(X1,X2) AND(X1,mark(X2)) -> AND(X1,X2) ISLIST(active(X)) -> ISLIST(X) ISLIST(mark(X)) -> ISLIST(X) ISNELIST(active(X)) -> ISNELIST(X) ISNELIST(mark(X)) -> ISNELIST(X) ISNEPAL(active(X)) -> ISNEPAL(X) ISNEPAL(mark(X)) -> ISNEPAL(X) ISPAL(active(X)) -> ISPAL(X) ISPAL(mark(X)) -> ISPAL(X) ISQID(active(X)) -> ISQID(X) ISQID(mark(X)) -> ISQID(X) MARK(__(X1,X2)) -> __#(mark(X1),mark(X2)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> AND(mark(X1),X2) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: ISQID(active(X)) -> ISQID(X) ISQID(mark(X)) -> ISQID(X) ->->-> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->->Cycle: ->->-> Pairs: ISPAL(active(X)) -> ISPAL(X) ISPAL(mark(X)) -> ISPAL(X) ->->-> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->->Cycle: ->->-> Pairs: ISNEPAL(active(X)) -> ISNEPAL(X) ISNEPAL(mark(X)) -> ISNEPAL(X) ->->-> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->->Cycle: ->->-> Pairs: ISNELIST(active(X)) -> ISNELIST(X) ISNELIST(mark(X)) -> ISNELIST(X) ->->-> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->->Cycle: ->->-> Pairs: ISLIST(active(X)) -> ISLIST(X) ISLIST(mark(X)) -> ISLIST(X) ->->-> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->->Cycle: ->->-> Pairs: AND(active(X1),X2) -> AND(X1,X2) AND(mark(X1),X2) -> AND(X1,X2) AND(X1,active(X2)) -> AND(X1,X2) AND(X1,mark(X2)) -> AND(X1,X2) ->->-> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->->Cycle: ->->-> Pairs: __#(active(X1),X2) -> __#(X1,X2) __#(mark(X1),X2) -> __#(X1,X2) __#(X1,active(X2)) -> __#(X1,X2) __#(X1,mark(X2)) -> __#(X1,X2) ->->-> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->->Cycle: ->->-> Pairs: ACTIVE(__(__(X,Y),Z)) -> MARK(__(X,__(Y,Z))) ACTIVE(__(nil,X)) -> MARK(X) ACTIVE(__(X,nil)) -> MARK(X) ACTIVE(and(tt,X)) -> MARK(X) ACTIVE(isList(__(V1,V2))) -> MARK(and(isList(V1),isList(V2))) ACTIVE(isList(V)) -> MARK(isNeList(V)) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isList(V1),isNeList(V2))) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) ->->-> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) The problem is decomposed in 8 subproblems. Problem 1.1: Subterm Processor: -> Pairs: ISQID(active(X)) -> ISQID(X) ISQID(mark(X)) -> ISQID(X) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Projection: pi(ISQID) = 1 Problem 1.1: SCC Processor: -> Pairs: Empty -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Strongly Connected Components: There is no strongly connected component The problem is finite. Problem 1.2: Subterm Processor: -> Pairs: ISPAL(active(X)) -> ISPAL(X) ISPAL(mark(X)) -> ISPAL(X) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Projection: pi(ISPAL) = 1 Problem 1.2: SCC Processor: -> Pairs: Empty -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Strongly Connected Components: There is no strongly connected component The problem is finite. Problem 1.3: Subterm Processor: -> Pairs: ISNEPAL(active(X)) -> ISNEPAL(X) ISNEPAL(mark(X)) -> ISNEPAL(X) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Projection: pi(ISNEPAL) = 1 Problem 1.3: SCC Processor: -> Pairs: Empty -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Strongly Connected Components: There is no strongly connected component The problem is finite. Problem 1.4: Subterm Processor: -> Pairs: ISNELIST(active(X)) -> ISNELIST(X) ISNELIST(mark(X)) -> ISNELIST(X) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Projection: pi(ISNELIST) = 1 Problem 1.4: SCC Processor: -> Pairs: Empty -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Strongly Connected Components: There is no strongly connected component The problem is finite. Problem 1.5: Subterm Processor: -> Pairs: ISLIST(active(X)) -> ISLIST(X) ISLIST(mark(X)) -> ISLIST(X) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Projection: pi(ISLIST) = 1 Problem 1.5: SCC Processor: -> Pairs: Empty -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Strongly Connected Components: There is no strongly connected component The problem is finite. Problem 1.6: Subterm Processor: -> Pairs: AND(active(X1),X2) -> AND(X1,X2) AND(mark(X1),X2) -> AND(X1,X2) AND(X1,active(X2)) -> AND(X1,X2) AND(X1,mark(X2)) -> AND(X1,X2) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Projection: pi(AND) = 1 Problem 1.6: SCC Processor: -> Pairs: AND(X1,active(X2)) -> AND(X1,X2) AND(X1,mark(X2)) -> AND(X1,X2) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: AND(X1,active(X2)) -> AND(X1,X2) AND(X1,mark(X2)) -> AND(X1,X2) ->->-> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) Problem 1.6: Subterm Processor: -> Pairs: AND(X1,active(X2)) -> AND(X1,X2) AND(X1,mark(X2)) -> AND(X1,X2) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Projection: pi(AND) = 2 Problem 1.6: SCC Processor: -> Pairs: Empty -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Strongly Connected Components: There is no strongly connected component The problem is finite. Problem 1.7: Subterm Processor: -> Pairs: __#(active(X1),X2) -> __#(X1,X2) __#(mark(X1),X2) -> __#(X1,X2) __#(X1,active(X2)) -> __#(X1,X2) __#(X1,mark(X2)) -> __#(X1,X2) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Projection: pi(__#) = 1 Problem 1.7: SCC Processor: -> Pairs: __#(X1,active(X2)) -> __#(X1,X2) __#(X1,mark(X2)) -> __#(X1,X2) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: __#(X1,active(X2)) -> __#(X1,X2) __#(X1,mark(X2)) -> __#(X1,X2) ->->-> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) Problem 1.7: Subterm Processor: -> Pairs: __#(X1,active(X2)) -> __#(X1,X2) __#(X1,mark(X2)) -> __#(X1,X2) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Projection: pi(__#) = 2 Problem 1.7: SCC Processor: -> Pairs: Empty -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Strongly Connected Components: There is no strongly connected component The problem is finite. Problem 1.8: Reduction Pair Processor: -> Pairs: ACTIVE(__(__(X,Y),Z)) -> MARK(__(X,__(Y,Z))) ACTIVE(__(nil,X)) -> MARK(X) ACTIVE(__(X,nil)) -> MARK(X) ACTIVE(and(tt,X)) -> MARK(X) ACTIVE(isList(__(V1,V2))) -> MARK(and(isList(V1),isList(V2))) ACTIVE(isList(V)) -> MARK(isNeList(V)) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isList(V1),isNeList(V2))) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) -> Usable rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Interpretation type: Linear ->Coefficients: Natural Numbers ->Dimension: 1 ->Bound: 2 ->Interpretation: [__](X1,X2) = 2.X1 + X2 + 2 [active](X) = X [and](X1,X2) = 2.X1 + 2.X2 [isList](X) = 0 [isNeList](X) = 0 [isNePal](X) = 0 [isPal](X) = 0 [isQid](X) = 0 [mark](X) = X [a] = 1 [e] = 2 [i] = 2 [nil] = 2 [o] = 1 [tt] = 0 [u] = 2 [ACTIVE](X) = 2.X [MARK](X) = 2.X Problem 1.8: SCC Processor: -> Pairs: ACTIVE(__(nil,X)) -> MARK(X) ACTIVE(__(X,nil)) -> MARK(X) ACTIVE(and(tt,X)) -> MARK(X) ACTIVE(isList(__(V1,V2))) -> MARK(and(isList(V1),isList(V2))) ACTIVE(isList(V)) -> MARK(isNeList(V)) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isList(V1),isNeList(V2))) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: ACTIVE(__(nil,X)) -> MARK(X) ACTIVE(__(X,nil)) -> MARK(X) ACTIVE(and(tt,X)) -> MARK(X) ACTIVE(isList(__(V1,V2))) -> MARK(and(isList(V1),isList(V2))) ACTIVE(isList(V)) -> MARK(isNeList(V)) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isList(V1),isNeList(V2))) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) ->->-> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) Problem 1.8: Reduction Pair Processor: -> Pairs: ACTIVE(__(nil,X)) -> MARK(X) ACTIVE(__(X,nil)) -> MARK(X) ACTIVE(and(tt,X)) -> MARK(X) ACTIVE(isList(__(V1,V2))) -> MARK(and(isList(V1),isList(V2))) ACTIVE(isList(V)) -> MARK(isNeList(V)) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isList(V1),isNeList(V2))) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) -> Usable rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Interpretation type: Linear ->Coefficients: Natural Numbers ->Dimension: 1 ->Bound: 2 ->Interpretation: [__](X1,X2) = 2.X1 + X2 + 2 [active](X) = X [and](X1,X2) = 2.X1 + 2.X2 [isList](X) = 0 [isNeList](X) = 0 [isNePal](X) = 2.X [isPal](X) = 2.X + 2 [isQid](X) = 0 [mark](X) = X [a] = 0 [e] = 2 [i] = 0 [nil] = 2 [o] = 2 [tt] = 0 [u] = 2 [ACTIVE](X) = 2.X + 2 [MARK](X) = 2.X + 2 Problem 1.8: SCC Processor: -> Pairs: ACTIVE(__(X,nil)) -> MARK(X) ACTIVE(and(tt,X)) -> MARK(X) ACTIVE(isList(__(V1,V2))) -> MARK(and(isList(V1),isList(V2))) ACTIVE(isList(V)) -> MARK(isNeList(V)) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isList(V1),isNeList(V2))) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: ACTIVE(__(X,nil)) -> MARK(X) ACTIVE(and(tt,X)) -> MARK(X) ACTIVE(isList(__(V1,V2))) -> MARK(and(isList(V1),isList(V2))) ACTIVE(isList(V)) -> MARK(isNeList(V)) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isList(V1),isNeList(V2))) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) ->->-> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) Problem 1.8: Reduction Pair Processor: -> Pairs: ACTIVE(__(X,nil)) -> MARK(X) ACTIVE(and(tt,X)) -> MARK(X) ACTIVE(isList(__(V1,V2))) -> MARK(and(isList(V1),isList(V2))) ACTIVE(isList(V)) -> MARK(isNeList(V)) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isList(V1),isNeList(V2))) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) -> Usable rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Interpretation type: Linear ->Coefficients: Natural Numbers ->Dimension: 1 ->Bound: 2 ->Interpretation: [__](X1,X2) = X1 + X2 [active](X) = X [and](X1,X2) = X1 + X2 [isList](X) = 2.X [isNeList](X) = 2.X [isNePal](X) = 2.X + 2 [isPal](X) = 2.X + 2 [isQid](X) = 2.X [mark](X) = X [a] = 2 [e] = 1 [i] = 2 [nil] = 2 [o] = 1 [tt] = 1 [u] = 2 [ACTIVE](X) = 2.X + 2 [MARK](X) = 2.X + 2 Problem 1.8: SCC Processor: -> Pairs: ACTIVE(and(tt,X)) -> MARK(X) ACTIVE(isList(__(V1,V2))) -> MARK(and(isList(V1),isList(V2))) ACTIVE(isList(V)) -> MARK(isNeList(V)) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isList(V1),isNeList(V2))) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: ACTIVE(and(tt,X)) -> MARK(X) ACTIVE(isList(__(V1,V2))) -> MARK(and(isList(V1),isList(V2))) ACTIVE(isList(V)) -> MARK(isNeList(V)) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isList(V1),isNeList(V2))) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) ->->-> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) Problem 1.8: Reduction Pair Processor: -> Pairs: ACTIVE(and(tt,X)) -> MARK(X) ACTIVE(isList(__(V1,V2))) -> MARK(and(isList(V1),isList(V2))) ACTIVE(isList(V)) -> MARK(isNeList(V)) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isList(V1),isNeList(V2))) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) -> Usable rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Interpretation type: Linear ->Coefficients: Natural Numbers ->Dimension: 1 ->Bound: 2 ->Interpretation: [__](X1,X2) = 2.X1 + X2 + 2 [active](X) = X [and](X1,X2) = 2.X1 + X2 [isList](X) = 2.X + 2 [isNeList](X) = 2.X + 2 [isNePal](X) = 2.X + 2 [isPal](X) = 2.X + 2 [isQid](X) = 2 [mark](X) = X [a] = 0 [e] = 0 [i] = 1 [nil] = 2 [o] = 0 [tt] = 2 [u] = 2 [ACTIVE](X) = 2.X + 1 [MARK](X) = 2.X + 1 Problem 1.8: SCC Processor: -> Pairs: ACTIVE(isList(__(V1,V2))) -> MARK(and(isList(V1),isList(V2))) ACTIVE(isList(V)) -> MARK(isNeList(V)) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isList(V1),isNeList(V2))) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: ACTIVE(isList(__(V1,V2))) -> MARK(and(isList(V1),isList(V2))) ACTIVE(isList(V)) -> MARK(isNeList(V)) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isList(V1),isNeList(V2))) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) ->->-> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) Problem 1.8: Reduction Pair Processor: -> Pairs: ACTIVE(isList(__(V1,V2))) -> MARK(and(isList(V1),isList(V2))) ACTIVE(isList(V)) -> MARK(isNeList(V)) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isList(V1),isNeList(V2))) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) -> Usable rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Interpretation type: Linear ->Coefficients: Natural Numbers ->Dimension: 1 ->Bound: 2 ->Interpretation: [__](X1,X2) = 2.X1 + X2 + 2 [active](X) = X [and](X1,X2) = X1 + X2 + 2 [isList](X) = 2.X + 1 [isNeList](X) = 2.X + 1 [isNePal](X) = X + 2 [isPal](X) = 2.X + 2 [isQid](X) = 1 [mark](X) = X [a] = 0 [e] = 2 [i] = 2 [nil] = 2 [o] = 0 [tt] = 1 [u] = 1 [ACTIVE](X) = 2.X + 2 [MARK](X) = 2.X + 2 Problem 1.8: SCC Processor: -> Pairs: ACTIVE(isList(V)) -> MARK(isNeList(V)) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isList(V1),isNeList(V2))) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: ACTIVE(isList(V)) -> MARK(isNeList(V)) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isList(V1),isNeList(V2))) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) ->->-> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) Problem 1.8: Reduction Pair Processor: -> Pairs: ACTIVE(isList(V)) -> MARK(isNeList(V)) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isList(V1),isNeList(V2))) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) -> Usable rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Interpretation type: Linear ->Coefficients: Natural Numbers ->Dimension: 1 ->Bound: 2 ->Interpretation: [__](X1,X2) = 2.X1 + X2 + 2 [active](X) = X [and](X1,X2) = 2.X1 + X2 [isList](X) = 2.X + 2 [isNeList](X) = 2.X + 1 [isNePal](X) = 2.X + 2 [isPal](X) = 2.X + 2 [isQid](X) = 2.X + 1 [mark](X) = X [a] = 1 [e] = 2 [i] = 1 [nil] = 2 [o] = 1 [tt] = 2 [u] = 2 [ACTIVE](X) = 2.X + 2 [MARK](X) = 2.X + 2 Problem 1.8: SCC Processor: -> Pairs: ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isList(V1),isNeList(V2))) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isList(V1),isNeList(V2))) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) ->->-> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) Problem 1.8: Reduction Pair Processor: -> Pairs: ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isList(V1),isNeList(V2))) ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) -> Usable rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Interpretation type: Linear ->Coefficients: Natural Numbers ->Dimension: 1 ->Bound: 2 ->Interpretation: [__](X1,X2) = 2.X1 + X2 + 2 [active](X) = X [and](X1,X2) = X1 + X2 + 1 [isList](X) = 2.X + 2 [isNeList](X) = 2.X + 2 [isNePal](X) = 2.X + 2 [isPal](X) = 2.X + 2 [isQid](X) = 2.X + 2 [mark](X) = X [a] = 2 [e] = 0 [i] = 2 [nil] = 2 [o] = 2 [tt] = 2 [u] = 2 [ACTIVE](X) = 2.X + 2 [MARK](X) = 2.X + 2 Problem 1.8: SCC Processor: -> Pairs: ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) ->->-> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) Problem 1.8: Reduction Pair Processor: -> Pairs: ACTIVE(isNeList(__(V1,V2))) -> MARK(and(isNeList(V1),isList(V2))) ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) -> Usable rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Interpretation type: Linear ->Coefficients: Natural Numbers ->Dimension: 1 ->Bound: 2 ->Interpretation: [__](X1,X2) = 2.X1 + X2 + 2 [active](X) = X [and](X1,X2) = 2.X1 + X2 + 1 [isList](X) = 2.X + 1 [isNeList](X) = 2.X + 1 [isNePal](X) = 2.X + 2 [isPal](X) = 2.X + 2 [isQid](X) = 2.X [mark](X) = X [a] = 2 [e] = 2 [i] = 1 [nil] = 2 [o] = 2 [tt] = 2 [u] = 1 [ACTIVE](X) = X + 2 [MARK](X) = X + 2 Problem 1.8: SCC Processor: -> Pairs: ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) ->->-> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) Problem 1.8: Reduction Pair Processor: -> Pairs: ACTIVE(isNeList(V)) -> MARK(isQid(V)) ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) -> Usable rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Interpretation type: Linear ->Coefficients: Natural Numbers ->Dimension: 1 ->Bound: 2 ->Interpretation: [__](X1,X2) = 2.X1 + X2 + 1 [active](X) = X [and](X1,X2) = X1 + X2 [isList](X) = 2.X + 2 [isNeList](X) = 2.X + 2 [isNePal](X) = 2.X + 2 [isPal](X) = 2.X + 2 [isQid](X) = 2.X + 1 [mark](X) = X [a] = 2 [e] = 2 [i] = 2 [nil] = 1 [o] = 2 [tt] = 0 [u] = 2 [ACTIVE](X) = 2.X + 2 [MARK](X) = 2.X + 2 Problem 1.8: SCC Processor: -> Pairs: ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) ->->-> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) Problem 1.8: Reduction Pair Processor: -> Pairs: ACTIVE(isNePal(__(I,__(P,I)))) -> MARK(and(isQid(I),isPal(P))) ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) -> Usable rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Interpretation type: Linear ->Coefficients: Natural Numbers ->Dimension: 1 ->Bound: 2 ->Interpretation: [__](X1,X2) = 2.X1 + X2 + 2 [active](X) = X [and](X1,X2) = X1 + 2.X2 [isList](X) = 0 [isNeList](X) = 0 [isNePal](X) = X [isPal](X) = X + 1 [isQid](X) = 0 [mark](X) = X [a] = 2 [e] = 2 [i] = 1 [nil] = 1 [o] = 1 [tt] = 0 [u] = 2 [ACTIVE](X) = 2.X [MARK](X) = 2.X Problem 1.8: SCC Processor: -> Pairs: ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) ->->-> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) Problem 1.8: Reduction Pair Processor: -> Pairs: ACTIVE(isNePal(V)) -> MARK(isQid(V)) ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) -> Usable rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Interpretation type: Linear ->Coefficients: Natural Numbers ->Dimension: 1 ->Bound: 2 ->Interpretation: [__](X1,X2) = 2.X1 + X2 + 2 [active](X) = X [and](X1,X2) = 2.X1 + 2.X2 [isList](X) = 0 [isNeList](X) = 0 [isNePal](X) = 2.X + 2 [isPal](X) = 2.X + 2 [isQid](X) = 0 [mark](X) = X [a] = 0 [e] = 2 [i] = 1 [nil] = 0 [o] = 0 [tt] = 0 [u] = 2 [ACTIVE](X) = 2.X + 2 [MARK](X) = 2.X + 2 Problem 1.8: SCC Processor: -> Pairs: ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) ->->-> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) Problem 1.8: Reduction Pair Processor: -> Pairs: ACTIVE(isPal(V)) -> MARK(isNePal(V)) MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) -> Usable rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Interpretation type: Linear ->Coefficients: Natural Numbers ->Dimension: 1 ->Bound: 2 ->Interpretation: [__](X1,X2) = 2.X1 + X2 + 2 [active](X) = X [and](X1,X2) = 2.X1 + 2.X2 [isList](X) = 0 [isNeList](X) = 0 [isNePal](X) = 2.X [isPal](X) = 2.X + 2 [isQid](X) = 0 [mark](X) = X [a] = 2 [e] = 2 [i] = 2 [nil] = 2 [o] = 2 [tt] = 0 [u] = 2 [ACTIVE](X) = 2.X + 2 [MARK](X) = 2.X + 2 Problem 1.8: SCC Processor: -> Pairs: MARK(__(X1,X2)) -> ACTIVE(__(mark(X1),mark(X2))) MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> ACTIVE(and(mark(X1),X2)) MARK(and(X1,X2)) -> MARK(X1) MARK(isList(X)) -> ACTIVE(isList(X)) MARK(isNeList(X)) -> ACTIVE(isNeList(X)) MARK(isNePal(X)) -> ACTIVE(isNePal(X)) MARK(isPal(X)) -> ACTIVE(isPal(X)) MARK(isQid(X)) -> ACTIVE(isQid(X)) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> MARK(X1) ->->-> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) Problem 1.8: Subterm Processor: -> Pairs: MARK(__(X1,X2)) -> MARK(X1) MARK(__(X1,X2)) -> MARK(X2) MARK(and(X1,X2)) -> MARK(X1) -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Projection: pi(MARK) = 1 Problem 1.8: SCC Processor: -> Pairs: Empty -> Rules: __(active(X1),X2) -> __(X1,X2) __(mark(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(nil,X)) -> mark(X) active(__(X,nil)) -> mark(X) active(and(tt,X)) -> mark(X) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isList(nil)) -> mark(tt) active(isList(V)) -> mark(isNeList(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isNePal(V)) -> mark(isQid(V)) active(isPal(nil)) -> mark(tt) active(isPal(V)) -> mark(isNePal(V)) active(isQid(a)) -> mark(tt) active(isQid(e)) -> mark(tt) active(isQid(i)) -> mark(tt) active(isQid(o)) -> mark(tt) active(isQid(u)) -> mark(tt) and(active(X1),X2) -> and(X1,X2) and(mark(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) isList(active(X)) -> isList(X) isList(mark(X)) -> isList(X) isNeList(active(X)) -> isNeList(X) isNeList(mark(X)) -> isNeList(X) isNePal(active(X)) -> isNePal(X) isNePal(mark(X)) -> isNePal(X) isPal(active(X)) -> isPal(X) isPal(mark(X)) -> isPal(X) isQid(active(X)) -> isQid(X) isQid(mark(X)) -> isQid(X) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(isQid(X)) -> active(isQid(X)) mark(a) -> active(a) mark(e) -> active(e) mark(i) -> active(i) mark(nil) -> active(nil) mark(o) -> active(o) mark(tt) -> active(tt) mark(u) -> active(u) ->Strongly Connected Components: There is no strongly connected component The problem is finite.