MAYBE

Problem:
 f(true(),x,y) -> f(and(gt(x,y),gt(y,s(s(0())))),plus(s(0()),x),double(y))
 gt(0(),v) -> false()
 gt(s(u),0()) -> true()
 gt(s(u),s(v)) -> gt(u,v)
 and(x,true()) -> x
 and(x,false()) -> false()
 plus(n,0()) -> n
 plus(n,s(m)) -> s(plus(n,m))
 plus(plus(n,m),u) -> plus(n,plus(m,u))
 double(0()) -> 0()
 double(s(x)) -> s(s(double(x)))

Proof:
 DP Processor:
  DPs:
   f#(true(),x,y) -> double#(y)
   f#(true(),x,y) -> plus#(s(0()),x)
   f#(true(),x,y) -> gt#(y,s(s(0())))
   f#(true(),x,y) -> gt#(x,y)
   f#(true(),x,y) -> and#(gt(x,y),gt(y,s(s(0()))))
   f#(true(),x,y) -> f#(and(gt(x,y),gt(y,s(s(0())))),plus(s(0()),x),double(y))
   gt#(s(u),s(v)) -> gt#(u,v)
   plus#(n,s(m)) -> plus#(n,m)
   plus#(plus(n,m),u) -> plus#(m,u)
   plus#(plus(n,m),u) -> plus#(n,plus(m,u))
   double#(s(x)) -> double#(x)
  TRS:
   f(true(),x,y) -> f(and(gt(x,y),gt(y,s(s(0())))),plus(s(0()),x),double(y))
   gt(0(),v) -> false()
   gt(s(u),0()) -> true()
   gt(s(u),s(v)) -> gt(u,v)
   and(x,true()) -> x
   and(x,false()) -> false()
   plus(n,0()) -> n
   plus(n,s(m)) -> s(plus(n,m))
   plus(plus(n,m),u) -> plus(n,plus(m,u))
   double(0()) -> 0()
   double(s(x)) -> s(s(double(x)))
  Usable Rule Processor:
   DPs:
    f#(true(),x,y) -> double#(y)
    f#(true(),x,y) -> plus#(s(0()),x)
    f#(true(),x,y) -> gt#(y,s(s(0())))
    f#(true(),x,y) -> gt#(x,y)
    f#(true(),x,y) -> and#(gt(x,y),gt(y,s(s(0()))))
    f#(true(),x,y) -> f#(and(gt(x,y),gt(y,s(s(0())))),plus(s(0()),x),double(y))
    gt#(s(u),s(v)) -> gt#(u,v)
    plus#(n,s(m)) -> plus#(n,m)
    plus#(plus(n,m),u) -> plus#(m,u)
    plus#(plus(n,m),u) -> plus#(n,plus(m,u))
    double#(s(x)) -> double#(x)
   TRS:
    gt(0(),v) -> false()
    gt(s(u),s(v)) -> gt(u,v)
    gt(s(u),0()) -> true()
    double(0()) -> 0()
    double(s(x)) -> s(s(double(x)))
    plus(n,0()) -> n
    plus(n,s(m)) -> s(plus(n,m))
    plus(plus(n,m),u) -> plus(n,plus(m,u))
    and(x,true()) -> x
    and(x,false()) -> false()
   TDG Processor:
    DPs:
     f#(true(),x,y) -> double#(y)
     f#(true(),x,y) -> plus#(s(0()),x)
     f#(true(),x,y) -> gt#(y,s(s(0())))
     f#(true(),x,y) -> gt#(x,y)
     f#(true(),x,y) -> and#(gt(x,y),gt(y,s(s(0()))))
     f#(true(),x,y) -> f#(and(gt(x,y),gt(y,s(s(0())))),plus(s(0()),x),double(y))
     gt#(s(u),s(v)) -> gt#(u,v)
     plus#(n,s(m)) -> plus#(n,m)
     plus#(plus(n,m),u) -> plus#(m,u)
     plus#(plus(n,m),u) -> plus#(n,plus(m,u))
     double#(s(x)) -> double#(x)
    TRS:
     gt(0(),v) -> false()
     gt(s(u),s(v)) -> gt(u,v)
     gt(s(u),0()) -> true()
     double(0()) -> 0()
     double(s(x)) -> s(s(double(x)))
     plus(n,0()) -> n
     plus(n,s(m)) -> s(plus(n,m))
     plus(plus(n,m),u) -> plus(n,plus(m,u))
     and(x,true()) -> x
     and(x,false()) -> false()
    graph:
     gt#(s(u),s(v)) -> gt#(u,v) -> gt#(s(u),s(v)) -> gt#(u,v)
     plus#(plus(n,m),u) -> plus#(m,u) ->
     plus#(plus(n,m),u) -> plus#(n,plus(m,u))
     plus#(plus(n,m),u) -> plus#(m,u) ->
     plus#(plus(n,m),u) -> plus#(m,u)
     plus#(plus(n,m),u) -> plus#(m,u) ->
     plus#(n,s(m)) -> plus#(n,m)
     plus#(plus(n,m),u) -> plus#(n,plus(m,u)) ->
     plus#(plus(n,m),u) -> plus#(n,plus(m,u))
     plus#(plus(n,m),u) -> plus#(n,plus(m,u)) ->
     plus#(plus(n,m),u) -> plus#(m,u)
     plus#(plus(n,m),u) -> plus#(n,plus(m,u)) ->
     plus#(n,s(m)) -> plus#(n,m)
     plus#(n,s(m)) -> plus#(n,m) ->
     plus#(plus(n,m),u) -> plus#(n,plus(m,u))
     plus#(n,s(m)) -> plus#(n,m) -> plus#(plus(n,m),u) -> plus#(m,u)
     plus#(n,s(m)) -> plus#(n,m) -> plus#(n,s(m)) -> plus#(n,m)
     double#(s(x)) -> double#(x) -> double#(s(x)) -> double#(x)
     f#(true(),x,y) -> gt#(y,s(s(0()))) -> gt#(s(u),s(v)) -> gt#(u,v)
     f#(true(),x,y) -> gt#(x,y) -> gt#(s(u),s(v)) -> gt#(u,v)
     f#(true(),x,y) -> plus#(s(0()),x) ->
     plus#(plus(n,m),u) -> plus#(n,plus(m,u))
     f#(true(),x,y) -> plus#(s(0()),x) ->
     plus#(plus(n,m),u) -> plus#(m,u)
     f#(true(),x,y) -> plus#(s(0()),x) -> plus#(n,s(m)) -> plus#(n,m)
     f#(true(),x,y) -> double#(y) ->
     double#(s(x)) -> double#(x)
     f#(true(),x,y) -> f#(and(gt(x,y),gt(y,s(s(0())))),plus(s(0()),x),double(y)) ->
     f#(true(),x,y) -> f#(and(gt(x,y),gt(y,s(s(0())))),plus(s(0()),x),double(y))
     f#(true(),x,y) -> f#(and(gt(x,y),gt(y,s(s(0())))),plus(s(0()),x),double(y)) ->
     f#(true(),x,y) -> and#(gt(x,y),gt(y,s(s(0()))))
     f#(true(),x,y) -> f#(and(gt(x,y),gt(y,s(s(0())))),plus(s(0()),x),double(y)) ->
     f#(true(),x,y) -> gt#(x,y)
     f#(true(),x,y) -> f#(and(gt(x,y),gt(y,s(s(0())))),plus(s(0()),x),double(y)) ->
     f#(true(),x,y) -> gt#(y,s(s(0())))
     f#(true(),x,y) -> f#(and(gt(x,y),gt(y,s(s(0())))),plus(s(0()),x),double(y)) ->
     f#(true(),x,y) -> plus#(s(0()),x)
     f#(true(),x,y) -> f#(and(gt(x,y),gt(y,s(s(0())))),plus(s(0()),x),double(y)) ->
     f#(true(),x,y) -> double#(y)
    Restore Modifier:
     DPs:
      f#(true(),x,y) -> double#(y)
      f#(true(),x,y) -> plus#(s(0()),x)
      f#(true(),x,y) -> gt#(y,s(s(0())))
      f#(true(),x,y) -> gt#(x,y)
      f#(true(),x,y) -> and#(gt(x,y),gt(y,s(s(0()))))
      f#(true(),x,y) -> f#(and(gt(x,y),gt(y,s(s(0())))),plus(s(0()),x),double(y))
      gt#(s(u),s(v)) -> gt#(u,v)
      plus#(n,s(m)) -> plus#(n,m)
      plus#(plus(n,m),u) -> plus#(m,u)
      plus#(plus(n,m),u) -> plus#(n,plus(m,u))
      double#(s(x)) -> double#(x)
     TRS:
      f(true(),x,y) -> f(and(gt(x,y),gt(y,s(s(0())))),plus(s(0()),x),double(y))
      gt(0(),v) -> false()
      gt(s(u),0()) -> true()
      gt(s(u),s(v)) -> gt(u,v)
      and(x,true()) -> x
      and(x,false()) -> false()
      plus(n,0()) -> n
      plus(n,s(m)) -> s(plus(n,m))
      plus(plus(n,m),u) -> plus(n,plus(m,u))
      double(0()) -> 0()
      double(s(x)) -> s(s(double(x)))
     SCC Processor:
      #sccs: 4
      #rules: 6
      #arcs: 23/121
      DPs:
       f#(true(),x,y) -> f#(and(gt(x,y),gt(y,s(s(0())))),plus(s(0()),x),double(y))
      TRS:
       f(true(),x,y) -> f(and(gt(x,y),gt(y,s(s(0())))),plus(s(0()),x),double(y))
       gt(0(),v) -> false()
       gt(s(u),0()) -> true()
       gt(s(u),s(v)) -> gt(u,v)
       and(x,true()) -> x
       and(x,false()) -> false()
       plus(n,0()) -> n
       plus(n,s(m)) -> s(plus(n,m))
       plus(plus(n,m),u) -> plus(n,plus(m,u))
       double(0()) -> 0()
       double(s(x)) -> s(s(double(x)))
      Open
      
      DPs:
       double#(s(x)) -> double#(x)
      TRS:
       f(true(),x,y) -> f(and(gt(x,y),gt(y,s(s(0())))),plus(s(0()),x),double(y))
       gt(0(),v) -> false()
       gt(s(u),0()) -> true()
       gt(s(u),s(v)) -> gt(u,v)
       and(x,true()) -> x
       and(x,false()) -> false()
       plus(n,0()) -> n
       plus(n,s(m)) -> s(plus(n,m))
       plus(plus(n,m),u) -> plus(n,plus(m,u))
       double(0()) -> 0()
       double(s(x)) -> s(s(double(x)))
      Open
      
      DPs:
       plus#(plus(n,m),u) -> plus#(m,u)
       plus#(n,s(m)) -> plus#(n,m)
       plus#(plus(n,m),u) -> plus#(n,plus(m,u))
      TRS:
       f(true(),x,y) -> f(and(gt(x,y),gt(y,s(s(0())))),plus(s(0()),x),double(y))
       gt(0(),v) -> false()
       gt(s(u),0()) -> true()
       gt(s(u),s(v)) -> gt(u,v)
       and(x,true()) -> x
       and(x,false()) -> false()
       plus(n,0()) -> n
       plus(n,s(m)) -> s(plus(n,m))
       plus(plus(n,m),u) -> plus(n,plus(m,u))
       double(0()) -> 0()
       double(s(x)) -> s(s(double(x)))
      Matrix Interpretation Processor:
       dimension: 1
       interpretation:
        [plus#](x0, x1) = x0,
        
        [false] = 0,
        
        [double](x0) = 0,
        
        [plus](x0, x1) = x0 + x1 + 1,
        
        [and](x0, x1) = x0 + x1,
        
        [s](x0) = 0,
        
        [0] = 0,
        
        [gt](x0, x1) = 1,
        
        [f](x0, x1, x2) = 0,
        
        [true] = 1
       orientation:
        plus#(plus(n,m),u) = m + n + 1 >= m = plus#(m,u)
        
        plus#(n,s(m)) = n >= n = plus#(n,m)
        
        plus#(plus(n,m),u) = m + n + 1 >= n = plus#(n,plus(m,u))
        
        f(true(),x,y) = 0 >= 0 = f(and(gt(x,y),gt(y,s(s(0())))),plus(s(0()),x),double(y))
        
        gt(0(),v) = 1 >= 0 = false()
        
        gt(s(u),0()) = 1 >= 1 = true()
        
        gt(s(u),s(v)) = 1 >= 1 = gt(u,v)
        
        and(x,true()) = x + 1 >= x = x
        
        and(x,false()) = x >= 0 = false()
        
        plus(n,0()) = n + 1 >= n = n
        
        plus(n,s(m)) = n + 1 >= 0 = s(plus(n,m))
        
        plus(plus(n,m),u) = m + n + u + 2 >= m + n + u + 2 = plus(n,plus(m,u))
        
        double(0()) = 0 >= 0 = 0()
        
        double(s(x)) = 0 >= 0 = s(s(double(x)))
       problem:
        DPs:
         plus#(n,s(m)) -> plus#(n,m)
        TRS:
         f(true(),x,y) -> f(and(gt(x,y),gt(y,s(s(0())))),plus(s(0()),x),double(y))
         gt(0(),v) -> false()
         gt(s(u),0()) -> true()
         gt(s(u),s(v)) -> gt(u,v)
         and(x,true()) -> x
         and(x,false()) -> false()
         plus(n,0()) -> n
         plus(n,s(m)) -> s(plus(n,m))
         plus(plus(n,m),u) -> plus(n,plus(m,u))
         double(0()) -> 0()
         double(s(x)) -> s(s(double(x)))
       Open
      
      DPs:
       gt#(s(u),s(v)) -> gt#(u,v)
      TRS:
       f(true(),x,y) -> f(and(gt(x,y),gt(y,s(s(0())))),plus(s(0()),x),double(y))
       gt(0(),v) -> false()
       gt(s(u),0()) -> true()
       gt(s(u),s(v)) -> gt(u,v)
       and(x,true()) -> x
       and(x,false()) -> false()
       plus(n,0()) -> n
       plus(n,s(m)) -> s(plus(n,m))
       plus(plus(n,m),u) -> plus(n,plus(m,u))
       double(0()) -> 0()
       double(s(x)) -> s(s(double(x)))
      Open