MAYBE

Problem:
 app(nil(),k) -> k
 app(l,nil()) -> l
 app(cons(x,l),k) -> cons(x,app(l,k))
 sum(cons(x,nil())) -> cons(x,nil())
 sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
 sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
 plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
 plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
 plus(zero(),y) -> y
 plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
 id(x) -> x
 if(true(),x,y) -> x
 if(false(),x,y) -> y
 not(x) -> if(x,false(),true())
 gt(s(x),zero()) -> true()
 gt(zero(),y) -> false()
 gt(s(x),s(y)) -> gt(x,y)

Proof:
 DP Processor:
  DPs:
   app#(cons(x,l),k) -> app#(l,k)
   sum#(cons(x,cons(y,l))) -> plus#(x,y)
   sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l))
   sum#(app(l,cons(x,cons(y,k)))) -> sum#(cons(x,cons(y,k)))
   sum#(app(l,cons(x,cons(y,k)))) -> app#(l,sum(cons(x,cons(y,k))))
   sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k)))))
   plus#(s(x),s(y)) -> id#(y)
   plus#(s(x),s(y)) -> id#(x)
   plus#(s(x),s(y)) -> not#(gt(x,y))
   plus#(s(x),s(y)) -> if#(not(gt(x,y)),id(x),id(y))
   plus#(s(x),s(y)) -> gt#(x,y)
   plus#(s(x),s(y)) -> if#(gt(x,y),x,y)
   plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))
   plus#(s(x),x) -> id#(x)
   plus#(s(x),x) -> gt#(x,x)
   plus#(s(x),x) -> if#(gt(x,x),id(x),id(x))
   plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
   plus#(id(x),s(y)) -> gt#(s(y),y)
   plus#(id(x),s(y)) -> if#(gt(s(y),y),y,s(y))
   plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y)))
   not#(x) -> if#(x,false(),true())
   gt#(s(x),s(y)) -> gt#(x,y)
  TRS:
   app(nil(),k) -> k
   app(l,nil()) -> l
   app(cons(x,l),k) -> cons(x,app(l,k))
   sum(cons(x,nil())) -> cons(x,nil())
   sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
   sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
   plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
   plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
   plus(zero(),y) -> y
   plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
   id(x) -> x
   if(true(),x,y) -> x
   if(false(),x,y) -> y
   not(x) -> if(x,false(),true())
   gt(s(x),zero()) -> true()
   gt(zero(),y) -> false()
   gt(s(x),s(y)) -> gt(x,y)
  Usable Rule Processor:
   DPs:
    app#(cons(x,l),k) -> app#(l,k)
    sum#(cons(x,cons(y,l))) -> plus#(x,y)
    sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l))
    sum#(app(l,cons(x,cons(y,k)))) -> sum#(cons(x,cons(y,k)))
    sum#(app(l,cons(x,cons(y,k)))) -> app#(l,sum(cons(x,cons(y,k))))
    sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k)))))
    plus#(s(x),s(y)) -> id#(y)
    plus#(s(x),s(y)) -> id#(x)
    plus#(s(x),s(y)) -> not#(gt(x,y))
    plus#(s(x),s(y)) -> if#(not(gt(x,y)),id(x),id(y))
    plus#(s(x),s(y)) -> gt#(x,y)
    plus#(s(x),s(y)) -> if#(gt(x,y),x,y)
    plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))
    plus#(s(x),x) -> id#(x)
    plus#(s(x),x) -> gt#(x,x)
    plus#(s(x),x) -> if#(gt(x,x),id(x),id(x))
    plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
    plus#(id(x),s(y)) -> gt#(s(y),y)
    plus#(id(x),s(y)) -> if#(gt(s(y),y),y,s(y))
    plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y)))
    not#(x) -> if#(x,false(),true())
    gt#(s(x),s(y)) -> gt#(x,y)
   TRS:
    f20(x,y) -> x
    f20(x,y) -> y
    plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
    plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
    plus(zero(),y) -> y
    plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
    id(x) -> x
    not(x) -> if(x,false(),true())
    gt(s(x),zero()) -> true()
    gt(zero(),y) -> false()
    gt(s(x),s(y)) -> gt(x,y)
    if(true(),x,y) -> x
    if(false(),x,y) -> y
    sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
    sum(cons(x,nil())) -> cons(x,nil())
    app(nil(),k) -> k
    app(l,nil()) -> l
    app(cons(x,l),k) -> cons(x,app(l,k))
   CDG Processor:
    DPs:
     app#(cons(x,l),k) -> app#(l,k)
     sum#(cons(x,cons(y,l))) -> plus#(x,y)
     sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l))
     sum#(app(l,cons(x,cons(y,k)))) -> sum#(cons(x,cons(y,k)))
     sum#(app(l,cons(x,cons(y,k)))) -> app#(l,sum(cons(x,cons(y,k))))
     sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k)))))
     plus#(s(x),s(y)) -> id#(y)
     plus#(s(x),s(y)) -> id#(x)
     plus#(s(x),s(y)) -> not#(gt(x,y))
     plus#(s(x),s(y)) -> if#(not(gt(x,y)),id(x),id(y))
     plus#(s(x),s(y)) -> gt#(x,y)
     plus#(s(x),s(y)) -> if#(gt(x,y),x,y)
     plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))
     plus#(s(x),x) -> id#(x)
     plus#(s(x),x) -> gt#(x,x)
     plus#(s(x),x) -> if#(gt(x,x),id(x),id(x))
     plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
     plus#(id(x),s(y)) -> gt#(s(y),y)
     plus#(id(x),s(y)) -> if#(gt(s(y),y),y,s(y))
     plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y)))
     not#(x) -> if#(x,false(),true())
     gt#(s(x),s(y)) -> gt#(x,y)
    TRS:
     f20(x,y) -> x
     f20(x,y) -> y
     plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
     plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
     plus(zero(),y) -> y
     plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
     id(x) -> x
     not(x) -> if(x,false(),true())
     gt(s(x),zero()) -> true()
     gt(zero(),y) -> false()
     gt(s(x),s(y)) -> gt(x,y)
     if(true(),x,y) -> x
     if(false(),x,y) -> y
     sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
     sum(cons(x,nil())) -> cons(x,nil())
     app(nil(),k) -> k
     app(l,nil()) -> l
     app(cons(x,l),k) -> cons(x,app(l,k))
    graph:
     gt#(s(x),s(y)) -> gt#(x,y) -> gt#(s(x),s(y)) -> gt#(x,y)
     plus#(id(x),s(y)) -> gt#(s(y),y) ->
     gt#(s(x),s(y)) -> gt#(x,y)
     plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
     plus#(s(x),s(y)) -> id#(y)
     plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
     plus#(s(x),s(y)) -> id#(x)
     plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
     plus#(s(x),s(y)) -> not#(gt(x,y))
     plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
     plus#(s(x),s(y)) -> if#(not(gt(x,y)),id(x),id(y))
     plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
     plus#(s(x),s(y)) -> gt#(x,y)
     plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
     plus#(s(x),s(y)) -> if#(gt(x,y),x,y)
     plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
     plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))
     plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
     plus#(s(x),x) -> id#(x)
     plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
     plus#(s(x),x) -> gt#(x,x)
     plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
     plus#(s(x),x) -> if#(gt(x,x),id(x),id(x))
     plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
     plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
     plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
     plus#(id(x),s(y)) -> gt#(s(y),y)
     plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
     plus#(id(x),s(y)) -> if#(gt(s(y),y),y,s(y))
     plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y))) ->
     plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y)))
     plus#(s(x),s(y)) -> gt#(x,y) -> gt#(s(x),s(y)) -> gt#(x,y)
     plus#(s(x),s(y)) -> not#(gt(x,y)) ->
     not#(x) -> if#(x,false(),true())
     plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
     plus#(s(x),s(y)) -> id#(y)
     plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
     plus#(s(x),s(y)) -> id#(x)
     plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
     plus#(s(x),s(y)) -> not#(gt(x,y))
     plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
     plus#(s(x),s(y)) -> if#(not(gt(x,y)),id(x),id(y))
     plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
     plus#(s(x),s(y)) -> gt#(x,y)
     plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
     plus#(s(x),s(y)) -> if#(gt(x,y),x,y)
     plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
     plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))
     plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
     plus#(s(x),x) -> id#(x)
     plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
     plus#(s(x),x) -> gt#(x,x)
     plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
     plus#(s(x),x) -> if#(gt(x,x),id(x),id(x))
     plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
     plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
     plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
     plus#(id(x),s(y)) -> gt#(s(y),y)
     plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
     plus#(id(x),s(y)) -> if#(gt(s(y),y),y,s(y))
     plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y))) ->
     plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y)))
     plus#(s(x),x) -> gt#(x,x) ->
     gt#(s(x),s(y)) -> gt#(x,y)
     plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
     plus#(s(x),s(y)) -> id#(y)
     plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
     plus#(s(x),s(y)) -> id#(x)
     plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
     plus#(s(x),s(y)) -> not#(gt(x,y))
     plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
     plus#(s(x),s(y)) -> if#(not(gt(x,y)),id(x),id(y))
     plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
     plus#(s(x),s(y)) -> gt#(x,y)
     plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
     plus#(s(x),s(y)) -> if#(gt(x,y),x,y)
     plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
     plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))
     plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
     plus#(s(x),x) -> id#(x)
     plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
     plus#(s(x),x) -> gt#(x,x)
     plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
     plus#(s(x),x) -> if#(gt(x,x),id(x),id(x))
     plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
     plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
     plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
     plus#(id(x),s(y)) -> gt#(s(y),y)
     plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
     plus#(id(x),s(y)) -> if#(gt(s(y),y),y,s(y))
     plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x)) ->
     plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y)))
     sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
     plus#(s(x),s(y)) -> id#(y)
     sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
     plus#(s(x),s(y)) -> id#(x)
     sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
     plus#(s(x),s(y)) -> not#(gt(x,y))
     sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
     plus#(s(x),s(y)) -> if#(not(gt(x,y)),id(x),id(y))
     sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
     plus#(s(x),s(y)) -> gt#(x,y)
     sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
     plus#(s(x),s(y)) -> if#(gt(x,y),x,y)
     sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
     plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))
     sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
     plus#(s(x),x) -> id#(x)
     sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
     plus#(s(x),x) -> gt#(x,x)
     sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
     plus#(s(x),x) -> if#(gt(x,x),id(x),id(x))
     sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
     plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
     sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
     plus#(id(x),s(y)) -> gt#(s(y),y)
     sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
     plus#(id(x),s(y)) -> if#(gt(s(y),y),y,s(y))
     sum#(cons(x,cons(y,l))) -> plus#(x,y) ->
     plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y)))
     sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l)) ->
     sum#(cons(x,cons(y,l))) -> plus#(x,y)
     sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l)) ->
     sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l))
     sum#(app(l,cons(x,cons(y,k)))) -> sum#(cons(x,cons(y,k))) ->
     sum#(cons(x,cons(y,l))) -> plus#(x,y)
     sum#(app(l,cons(x,cons(y,k)))) -> sum#(cons(x,cons(y,k))) ->
     sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l))
     sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k))))) ->
     sum#(cons(x,cons(y,l))) -> plus#(x,y)
     sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k))))) ->
     sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l))
     sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k))))) ->
     sum#(app(l,cons(x,cons(y,k)))) -> sum#(cons(x,cons(y,k)))
     sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k))))) ->
     sum#(app(l,cons(x,cons(y,k)))) -> app#(l,sum(cons(x,cons(y,k))))
     sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k))))) ->
     sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k)))))
     sum#(app(l,cons(x,cons(y,k)))) -> app#(l,sum(cons(x,cons(y,k)))) ->
     app#(cons(x,l),k) -> app#(l,k)
     app#(cons(x,l),k) -> app#(l,k) -> app#(cons(x,l),k) -> app#(l,k)
    Restore Modifier:
     DPs:
      app#(cons(x,l),k) -> app#(l,k)
      sum#(cons(x,cons(y,l))) -> plus#(x,y)
      sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l))
      sum#(app(l,cons(x,cons(y,k)))) -> sum#(cons(x,cons(y,k)))
      sum#(app(l,cons(x,cons(y,k)))) -> app#(l,sum(cons(x,cons(y,k))))
      sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k)))))
      plus#(s(x),s(y)) -> id#(y)
      plus#(s(x),s(y)) -> id#(x)
      plus#(s(x),s(y)) -> not#(gt(x,y))
      plus#(s(x),s(y)) -> if#(not(gt(x,y)),id(x),id(y))
      plus#(s(x),s(y)) -> gt#(x,y)
      plus#(s(x),s(y)) -> if#(gt(x,y),x,y)
      plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))
      plus#(s(x),x) -> id#(x)
      plus#(s(x),x) -> gt#(x,x)
      plus#(s(x),x) -> if#(gt(x,x),id(x),id(x))
      plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
      plus#(id(x),s(y)) -> gt#(s(y),y)
      plus#(id(x),s(y)) -> if#(gt(s(y),y),y,s(y))
      plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y)))
      not#(x) -> if#(x,false(),true())
      gt#(s(x),s(y)) -> gt#(x,y)
     TRS:
      app(nil(),k) -> k
      app(l,nil()) -> l
      app(cons(x,l),k) -> cons(x,app(l,k))
      sum(cons(x,nil())) -> cons(x,nil())
      sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
      sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
      plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
      plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
      plus(zero(),y) -> y
      plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
      id(x) -> x
      if(true(),x,y) -> x
      if(false(),x,y) -> y
      not(x) -> if(x,false(),true())
      gt(s(x),zero()) -> true()
      gt(zero(),y) -> false()
      gt(s(x),s(y)) -> gt(x,y)
     SCC Processor:
      #sccs: 5
      #rules: 7
      #arcs: 72/484
      DPs:
       sum#(app(l,cons(x,cons(y,k)))) -> sum#(app(l,sum(cons(x,cons(y,k)))))
      TRS:
       app(nil(),k) -> k
       app(l,nil()) -> l
       app(cons(x,l),k) -> cons(x,app(l,k))
       sum(cons(x,nil())) -> cons(x,nil())
       sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
       sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
       plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
       plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
       plus(zero(),y) -> y
       plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
       id(x) -> x
       if(true(),x,y) -> x
       if(false(),x,y) -> y
       not(x) -> if(x,false(),true())
       gt(s(x),zero()) -> true()
       gt(zero(),y) -> false()
       gt(s(x),s(y)) -> gt(x,y)
      Matrix Interpretation Processor:
       dimension: 1
       interpretation:
        [sum#](x0) = x0,
        
        [false] = 0,
        
        [true] = 0,
        
        [zero] = 0,
        
        [id](x0) = x0,
        
        [not](x0) = x0 + 1,
        
        [if](x0, x1, x2) = x0 + x1 + x2,
        
        [gt](x0, x1) = 0,
        
        [s](x0) = 0,
        
        [plus](x0, x1) = x1 + 1,
        
        [sum](x0) = 1,
        
        [cons](x0, x1) = x1 + 1,
        
        [app](x0, x1) = x0 + x1 + 1,
        
        [nil] = 0
       orientation:
        sum#(app(l,cons(x,cons(y,k)))) = k + l + 3 >= l + 2 = sum#(app(l,sum(cons(x,cons(y,k)))))
        
        app(nil(),k) = k + 1 >= k = k
        
        app(l,nil()) = l + 1 >= l = l
        
        app(cons(x,l),k) = k + l + 2 >= k + l + 2 = cons(x,app(l,k))
        
        sum(cons(x,nil())) = 1 >= 1 = cons(x,nil())
        
        sum(cons(x,cons(y,l))) = 1 >= 1 = sum(cons(plus(x,y),l))
        
        sum(app(l,cons(x,cons(y,k)))) = 1 >= 1 = sum(app(l,sum(cons(x,cons(y,k)))))
        
        plus(s(x),s(y)) = 1 >= 0 = s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
        
        plus(s(x),x) = x + 1 >= 1 = plus(if(gt(x,x),id(x),id(x)),s(x))
        
        plus(zero(),y) = y + 1 >= y = y
        
        plus(id(x),s(y)) = 1 >= 0 = s(plus(x,if(gt(s(y),y),y,s(y))))
        
        id(x) = x >= x = x
        
        if(true(),x,y) = x + y >= x = x
        
        if(false(),x,y) = x + y >= y = y
        
        not(x) = x + 1 >= x = if(x,false(),true())
        
        gt(s(x),zero()) = 0 >= 0 = true()
        
        gt(zero(),y) = 0 >= 0 = false()
        
        gt(s(x),s(y)) = 0 >= 0 = gt(x,y)
       problem:
        DPs:
         
        TRS:
         app(nil(),k) -> k
         app(l,nil()) -> l
         app(cons(x,l),k) -> cons(x,app(l,k))
         sum(cons(x,nil())) -> cons(x,nil())
         sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
         sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
         plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
         plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
         plus(zero(),y) -> y
         plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
         id(x) -> x
         if(true(),x,y) -> x
         if(false(),x,y) -> y
         not(x) -> if(x,false(),true())
         gt(s(x),zero()) -> true()
         gt(zero(),y) -> false()
         gt(s(x),s(y)) -> gt(x,y)
       Qed
      
      DPs:
       app#(cons(x,l),k) -> app#(l,k)
      TRS:
       app(nil(),k) -> k
       app(l,nil()) -> l
       app(cons(x,l),k) -> cons(x,app(l,k))
       sum(cons(x,nil())) -> cons(x,nil())
       sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
       sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
       plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
       plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
       plus(zero(),y) -> y
       plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
       id(x) -> x
       if(true(),x,y) -> x
       if(false(),x,y) -> y
       not(x) -> if(x,false(),true())
       gt(s(x),zero()) -> true()
       gt(zero(),y) -> false()
       gt(s(x),s(y)) -> gt(x,y)
      Matrix Interpretation Processor:
       dimension: 1
       interpretation:
        [app#](x0, x1) = x0 + 1,
        
        [false] = 0,
        
        [true] = 0,
        
        [zero] = 0,
        
        [id](x0) = x0 + 1,
        
        [not](x0) = 0,
        
        [if](x0, x1, x2) = x1 + x2,
        
        [gt](x0, x1) = 0,
        
        [s](x0) = 0,
        
        [plus](x0, x1) = x1,
        
        [sum](x0) = 1,
        
        [cons](x0, x1) = x1 + 1,
        
        [app](x0, x1) = x0 + x1 + 1,
        
        [nil] = 0
       orientation:
        app#(cons(x,l),k) = l + 2 >= l + 1 = app#(l,k)
        
        app(nil(),k) = k + 1 >= k = k
        
        app(l,nil()) = l + 1 >= l = l
        
        app(cons(x,l),k) = k + l + 2 >= k + l + 2 = cons(x,app(l,k))
        
        sum(cons(x,nil())) = 1 >= 1 = cons(x,nil())
        
        sum(cons(x,cons(y,l))) = 1 >= 1 = sum(cons(plus(x,y),l))
        
        sum(app(l,cons(x,cons(y,k)))) = 1 >= 1 = sum(app(l,sum(cons(x,cons(y,k)))))
        
        plus(s(x),s(y)) = 0 >= 0 = s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
        
        plus(s(x),x) = x >= 0 = plus(if(gt(x,x),id(x),id(x)),s(x))
        
        plus(zero(),y) = y >= y = y
        
        plus(id(x),s(y)) = 0 >= 0 = s(plus(x,if(gt(s(y),y),y,s(y))))
        
        id(x) = x + 1 >= x = x
        
        if(true(),x,y) = x + y >= x = x
        
        if(false(),x,y) = x + y >= y = y
        
        not(x) = 0 >= 0 = if(x,false(),true())
        
        gt(s(x),zero()) = 0 >= 0 = true()
        
        gt(zero(),y) = 0 >= 0 = false()
        
        gt(s(x),s(y)) = 0 >= 0 = gt(x,y)
       problem:
        DPs:
         
        TRS:
         app(nil(),k) -> k
         app(l,nil()) -> l
         app(cons(x,l),k) -> cons(x,app(l,k))
         sum(cons(x,nil())) -> cons(x,nil())
         sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
         sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
         plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
         plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
         plus(zero(),y) -> y
         plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
         id(x) -> x
         if(true(),x,y) -> x
         if(false(),x,y) -> y
         not(x) -> if(x,false(),true())
         gt(s(x),zero()) -> true()
         gt(zero(),y) -> false()
         gt(s(x),s(y)) -> gt(x,y)
       Qed
      
      DPs:
       sum#(cons(x,cons(y,l))) -> sum#(cons(plus(x,y),l))
      TRS:
       app(nil(),k) -> k
       app(l,nil()) -> l
       app(cons(x,l),k) -> cons(x,app(l,k))
       sum(cons(x,nil())) -> cons(x,nil())
       sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
       sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
       plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
       plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
       plus(zero(),y) -> y
       plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
       id(x) -> x
       if(true(),x,y) -> x
       if(false(),x,y) -> y
       not(x) -> if(x,false(),true())
       gt(s(x),zero()) -> true()
       gt(zero(),y) -> false()
       gt(s(x),s(y)) -> gt(x,y)
      Matrix Interpretation Processor:
       dimension: 1
       interpretation:
        [sum#](x0) = x0,
        
        [false] = 0,
        
        [true] = 0,
        
        [zero] = 0,
        
        [id](x0) = x0,
        
        [not](x0) = x0 + 1,
        
        [if](x0, x1, x2) = x0 + x1 + x2,
        
        [gt](x0, x1) = 1,
        
        [s](x0) = 0,
        
        [plus](x0, x1) = x1,
        
        [sum](x0) = 1,
        
        [cons](x0, x1) = x1 + 1,
        
        [app](x0, x1) = x0 + x1,
        
        [nil] = 0
       orientation:
        sum#(cons(x,cons(y,l))) = l + 2 >= l + 1 = sum#(cons(plus(x,y),l))
        
        app(nil(),k) = k >= k = k
        
        app(l,nil()) = l >= l = l
        
        app(cons(x,l),k) = k + l + 1 >= k + l + 1 = cons(x,app(l,k))
        
        sum(cons(x,nil())) = 1 >= 1 = cons(x,nil())
        
        sum(cons(x,cons(y,l))) = 1 >= 1 = sum(cons(plus(x,y),l))
        
        sum(app(l,cons(x,cons(y,k)))) = 1 >= 1 = sum(app(l,sum(cons(x,cons(y,k)))))
        
        plus(s(x),s(y)) = 0 >= 0 = s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
        
        plus(s(x),x) = x >= 0 = plus(if(gt(x,x),id(x),id(x)),s(x))
        
        plus(zero(),y) = y >= y = y
        
        plus(id(x),s(y)) = 0 >= 0 = s(plus(x,if(gt(s(y),y),y,s(y))))
        
        id(x) = x >= x = x
        
        if(true(),x,y) = x + y >= x = x
        
        if(false(),x,y) = x + y >= y = y
        
        not(x) = x + 1 >= x = if(x,false(),true())
        
        gt(s(x),zero()) = 1 >= 0 = true()
        
        gt(zero(),y) = 1 >= 0 = false()
        
        gt(s(x),s(y)) = 1 >= 1 = gt(x,y)
       problem:
        DPs:
         
        TRS:
         app(nil(),k) -> k
         app(l,nil()) -> l
         app(cons(x,l),k) -> cons(x,app(l,k))
         sum(cons(x,nil())) -> cons(x,nil())
         sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
         sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
         plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
         plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
         plus(zero(),y) -> y
         plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
         id(x) -> x
         if(true(),x,y) -> x
         if(false(),x,y) -> y
         not(x) -> if(x,false(),true())
         gt(s(x),zero()) -> true()
         gt(zero(),y) -> false()
         gt(s(x),s(y)) -> gt(x,y)
       Qed
      
      DPs:
       plus#(id(x),s(y)) -> plus#(x,if(gt(s(y),y),y,s(y)))
       plus#(s(x),x) -> plus#(if(gt(x,x),id(x),id(x)),s(x))
       plus#(s(x),s(y)) -> plus#(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))
      TRS:
       app(nil(),k) -> k
       app(l,nil()) -> l
       app(cons(x,l),k) -> cons(x,app(l,k))
       sum(cons(x,nil())) -> cons(x,nil())
       sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
       sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
       plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
       plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
       plus(zero(),y) -> y
       plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
       id(x) -> x
       if(true(),x,y) -> x
       if(false(),x,y) -> y
       not(x) -> if(x,false(),true())
       gt(s(x),zero()) -> true()
       gt(zero(),y) -> false()
       gt(s(x),s(y)) -> gt(x,y)
      Open
      
      DPs:
       gt#(s(x),s(y)) -> gt#(x,y)
      TRS:
       app(nil(),k) -> k
       app(l,nil()) -> l
       app(cons(x,l),k) -> cons(x,app(l,k))
       sum(cons(x,nil())) -> cons(x,nil())
       sum(cons(x,cons(y,l))) -> sum(cons(plus(x,y),l))
       sum(app(l,cons(x,cons(y,k)))) -> sum(app(l,sum(cons(x,cons(y,k)))))
       plus(s(x),s(y)) -> s(s(plus(if(gt(x,y),x,y),if(not(gt(x,y)),id(x),id(y)))))
       plus(s(x),x) -> plus(if(gt(x,x),id(x),id(x)),s(x))
       plus(zero(),y) -> y
       plus(id(x),s(y)) -> s(plus(x,if(gt(s(y),y),y,s(y))))
       id(x) -> x
       if(true(),x,y) -> x
       if(false(),x,y) -> y
       not(x) -> if(x,false(),true())
       gt(s(x),zero()) -> true()
       gt(zero(),y) -> false()
       gt(s(x),s(y)) -> gt(x,y)
      Open