/export/starexec/sandbox/solver/bin/starexec_run_ttt2-1.17+nonreach /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files


--------------------------------------------------------------------------------


YES

Problem:
 plus(0(),x) -> x
 plus(s(x),y) -> s(plus(p(s(x)),y))
 times(0(),y) -> 0()
 times(s(x),y) -> plus(y,times(p(s(x)),y))
 exp(x,0()) -> s(0())
 exp(x,s(y)) -> times(x,exp(x,y))
 p(s(0())) -> 0()
 p(s(s(x))) -> s(p(s(x)))
 tower(x,y) -> towerIter(x,y,s(0()))
 towerIter(0(),y,z) -> z
 towerIter(s(x),y,z) -> towerIter(p(s(x)),y,exp(y,z))

Proof:
 DP Processor:
  DPs:
   plus#(s(x),y) -> p#(s(x))
   plus#(s(x),y) -> plus#(p(s(x)),y)
   times#(s(x),y) -> p#(s(x))
   times#(s(x),y) -> times#(p(s(x)),y)
   times#(s(x),y) -> plus#(y,times(p(s(x)),y))
   exp#(x,s(y)) -> exp#(x,y)
   exp#(x,s(y)) -> times#(x,exp(x,y))
   p#(s(s(x))) -> p#(s(x))
   tower#(x,y) -> towerIter#(x,y,s(0()))
   towerIter#(s(x),y,z) -> exp#(y,z)
   towerIter#(s(x),y,z) -> p#(s(x))
   towerIter#(s(x),y,z) -> towerIter#(p(s(x)),y,exp(y,z))
  TRS:
   plus(0(),x) -> x
   plus(s(x),y) -> s(plus(p(s(x)),y))
   times(0(),y) -> 0()
   times(s(x),y) -> plus(y,times(p(s(x)),y))
   exp(x,0()) -> s(0())
   exp(x,s(y)) -> times(x,exp(x,y))
   p(s(0())) -> 0()
   p(s(s(x))) -> s(p(s(x)))
   tower(x,y) -> towerIter(x,y,s(0()))
   towerIter(0(),y,z) -> z
   towerIter(s(x),y,z) -> towerIter(p(s(x)),y,exp(y,z))
  TDG Processor:
   DPs:
    plus#(s(x),y) -> p#(s(x))
    plus#(s(x),y) -> plus#(p(s(x)),y)
    times#(s(x),y) -> p#(s(x))
    times#(s(x),y) -> times#(p(s(x)),y)
    times#(s(x),y) -> plus#(y,times(p(s(x)),y))
    exp#(x,s(y)) -> exp#(x,y)
    exp#(x,s(y)) -> times#(x,exp(x,y))
    p#(s(s(x))) -> p#(s(x))
    tower#(x,y) -> towerIter#(x,y,s(0()))
    towerIter#(s(x),y,z) -> exp#(y,z)
    towerIter#(s(x),y,z) -> p#(s(x))
    towerIter#(s(x),y,z) -> towerIter#(p(s(x)),y,exp(y,z))
   TRS:
    plus(0(),x) -> x
    plus(s(x),y) -> s(plus(p(s(x)),y))
    times(0(),y) -> 0()
    times(s(x),y) -> plus(y,times(p(s(x)),y))
    exp(x,0()) -> s(0())
    exp(x,s(y)) -> times(x,exp(x,y))
    p(s(0())) -> 0()
    p(s(s(x))) -> s(p(s(x)))
    tower(x,y) -> towerIter(x,y,s(0()))
    towerIter(0(),y,z) -> z
    towerIter(s(x),y,z) -> towerIter(p(s(x)),y,exp(y,z))
   graph:
    towerIter#(s(x),y,z) -> towerIter#(p(s(x)),y,exp(y,z)) ->
    towerIter#(s(x),y,z) -> towerIter#(p(s(x)),y,exp(y,z))
    towerIter#(s(x),y,z) -> towerIter#(p(s(x)),y,exp(y,z)) ->
    towerIter#(s(x),y,z) -> p#(s(x))
    towerIter#(s(x),y,z) -> towerIter#(p(s(x)),y,exp(y,z)) ->
    towerIter#(s(x),y,z) -> exp#(y,z)
    towerIter#(s(x),y,z) -> exp#(y,z) ->
    exp#(x,s(y)) -> times#(x,exp(x,y))
    towerIter#(s(x),y,z) -> exp#(y,z) -> exp#(x,s(y)) -> exp#(x,y)
    towerIter#(s(x),y,z) -> p#(s(x)) ->
    p#(s(s(x))) -> p#(s(x))
    tower#(x,y) -> towerIter#(x,y,s(0())) ->
    towerIter#(s(x),y,z) -> towerIter#(p(s(x)),y,exp(y,z))
    tower#(x,y) -> towerIter#(x,y,s(0())) ->
    towerIter#(s(x),y,z) -> p#(s(x))
    tower#(x,y) -> towerIter#(x,y,s(0())) ->
    towerIter#(s(x),y,z) -> exp#(y,z)
    exp#(x,s(y)) -> exp#(x,y) -> exp#(x,s(y)) -> times#(x,exp(x,y))
    exp#(x,s(y)) -> exp#(x,y) -> exp#(x,s(y)) -> exp#(x,y)
    exp#(x,s(y)) -> times#(x,exp(x,y)) ->
    times#(s(x),y) -> plus#(y,times(p(s(x)),y))
    exp#(x,s(y)) -> times#(x,exp(x,y)) ->
    times#(s(x),y) -> times#(p(s(x)),y)
    exp#(x,s(y)) -> times#(x,exp(x,y)) ->
    times#(s(x),y) -> p#(s(x))
    times#(s(x),y) -> times#(p(s(x)),y) ->
    times#(s(x),y) -> plus#(y,times(p(s(x)),y))
    times#(s(x),y) -> times#(p(s(x)),y) ->
    times#(s(x),y) -> times#(p(s(x)),y)
    times#(s(x),y) -> times#(p(s(x)),y) -> times#(s(x),y) -> p#(s(x))
    times#(s(x),y) -> p#(s(x)) ->
    p#(s(s(x))) -> p#(s(x))
    times#(s(x),y) -> plus#(y,times(p(s(x)),y)) ->
    plus#(s(x),y) -> plus#(p(s(x)),y)
    times#(s(x),y) -> plus#(y,times(p(s(x)),y)) -> plus#(s(x),y) -> p#(s(x))
    p#(s(s(x))) -> p#(s(x)) -> p#(s(s(x))) -> p#(s(x))
    plus#(s(x),y) -> p#(s(x)) -> p#(s(s(x))) -> p#(s(x))
    plus#(s(x),y) -> plus#(p(s(x)),y) ->
    plus#(s(x),y) -> plus#(p(s(x)),y)
    plus#(s(x),y) -> plus#(p(s(x)),y) -> plus#(s(x),y) -> p#(s(x))
   SCC Processor:
    #sccs: 5
    #rules: 5
    #arcs: 24/144
    DPs:
     towerIter#(s(x),y,z) -> towerIter#(p(s(x)),y,exp(y,z))
    TRS:
     plus(0(),x) -> x
     plus(s(x),y) -> s(plus(p(s(x)),y))
     times(0(),y) -> 0()
     times(s(x),y) -> plus(y,times(p(s(x)),y))
     exp(x,0()) -> s(0())
     exp(x,s(y)) -> times(x,exp(x,y))
     p(s(0())) -> 0()
     p(s(s(x))) -> s(p(s(x)))
     tower(x,y) -> towerIter(x,y,s(0()))
     towerIter(0(),y,z) -> z
     towerIter(s(x),y,z) -> towerIter(p(s(x)),y,exp(y,z))
    Usable Rule Processor:
     DPs:
      towerIter#(s(x),y,z) -> towerIter#(p(s(x)),y,exp(y,z))
     TRS:
      exp(x,0()) -> s(0())
      exp(x,s(y)) -> times(x,exp(x,y))
      times(0(),y) -> 0()
      times(s(x),y) -> plus(y,times(p(s(x)),y))
      plus(0(),x) -> x
      plus(s(x),y) -> s(plus(p(s(x)),y))
      p(s(0())) -> 0()
      p(s(s(x))) -> s(p(s(x)))
     Arctic Interpretation Processor:
      dimension: 1
      usable rules:
       p(s(0())) -> 0()
       p(s(s(x))) -> s(p(s(x)))
      interpretation:
       [towerIter#](x0, x1, x2) = x0 + -16,
       
       [exp](x0, x1) = -8x0 + 1x1 + -8,
       
       [times](x0, x1) = -6x0 + x1 + 0,
       
       [p](x0) = -1x0 + 0,
       
       [s](x0) = 1x0 + 1,
       
       [plus](x0, x1) = -8x0 + 1,
       
       [0] = 0
      orientation:
       towerIter#(s(x),y,z) = 1x + 1 >= x + 0 = towerIter#(p(s(x)),y,exp(y,z))
       
       exp(x,0()) = -8x + 1 >= 1 = s(0())
       
       exp(x,s(y)) = -8x + 2y + 2 >= -6x + 1y + 0 = times(x,exp(x,y))
       
       times(0(),y) = y + 0 >= 0 = 0()
       
       times(s(x),y) = -5x + y + 0 >= -8y + 1 = plus(y,times(p(s(x)),y))
       
       plus(0(),x) = 1 >= x = x
       
       plus(s(x),y) = -7x + 1 >= -7x + 2 = s(plus(p(s(x)),y))
       
       p(s(0())) = 0 >= 0 = 0()
       
       p(s(s(x))) = 1x + 1 >= 1x + 1 = s(p(s(x)))
      problem:
       DPs:
        
       TRS:
        exp(x,0()) -> s(0())
        exp(x,s(y)) -> times(x,exp(x,y))
        times(0(),y) -> 0()
        times(s(x),y) -> plus(y,times(p(s(x)),y))
        plus(0(),x) -> x
        plus(s(x),y) -> s(plus(p(s(x)),y))
        p(s(0())) -> 0()
        p(s(s(x))) -> s(p(s(x)))
      Qed
    
    DPs:
     exp#(x,s(y)) -> exp#(x,y)
    TRS:
     plus(0(),x) -> x
     plus(s(x),y) -> s(plus(p(s(x)),y))
     times(0(),y) -> 0()
     times(s(x),y) -> plus(y,times(p(s(x)),y))
     exp(x,0()) -> s(0())
     exp(x,s(y)) -> times(x,exp(x,y))
     p(s(0())) -> 0()
     p(s(s(x))) -> s(p(s(x)))
     tower(x,y) -> towerIter(x,y,s(0()))
     towerIter(0(),y,z) -> z
     towerIter(s(x),y,z) -> towerIter(p(s(x)),y,exp(y,z))
    Subterm Criterion Processor:
     simple projection:
      pi(exp#) = 1
     problem:
      DPs:
       
      TRS:
       plus(0(),x) -> x
       plus(s(x),y) -> s(plus(p(s(x)),y))
       times(0(),y) -> 0()
       times(s(x),y) -> plus(y,times(p(s(x)),y))
       exp(x,0()) -> s(0())
       exp(x,s(y)) -> times(x,exp(x,y))
       p(s(0())) -> 0()
       p(s(s(x))) -> s(p(s(x)))
       tower(x,y) -> towerIter(x,y,s(0()))
       towerIter(0(),y,z) -> z
       towerIter(s(x),y,z) -> towerIter(p(s(x)),y,exp(y,z))
     Qed
    
    DPs:
     times#(s(x),y) -> times#(p(s(x)),y)
    TRS:
     plus(0(),x) -> x
     plus(s(x),y) -> s(plus(p(s(x)),y))
     times(0(),y) -> 0()
     times(s(x),y) -> plus(y,times(p(s(x)),y))
     exp(x,0()) -> s(0())
     exp(x,s(y)) -> times(x,exp(x,y))
     p(s(0())) -> 0()
     p(s(s(x))) -> s(p(s(x)))
     tower(x,y) -> towerIter(x,y,s(0()))
     towerIter(0(),y,z) -> z
     towerIter(s(x),y,z) -> towerIter(p(s(x)),y,exp(y,z))
    Usable Rule Processor:
     DPs:
      times#(s(x),y) -> times#(p(s(x)),y)
     TRS:
      p(s(0())) -> 0()
      p(s(s(x))) -> s(p(s(x)))
     Semantic Labeling Processor:
      dimension: 2
      usable rules:
       p(s(0())) -> 0()
       p(s(s(x))) -> s(p(s(x)))
      interpretation:
                 [1 0]  
       [p](x0) = [1 0]x0,
       
                 [0 1]     [0]
       [s](x0) = [0 1]x0 + [1],
       
             [0]
       [0] = [1]
       labeled:
        times#
        s
        p
        0
       usable (for model):
        times#
        s
        p
        0
       argument filtering:
        pi(0) = []
        pi(s) = []
        pi(p) = []
        pi(times#) = 0
      precedence:
       s > times# ~ p ~ 0
      problem:
       DPs:
        
       TRS:
        p(s(0())) -> 0()
        p(s(s(x))) -> s(p(s(x)))
      Qed
    
    DPs:
     plus#(s(x),y) -> plus#(p(s(x)),y)
    TRS:
     plus(0(),x) -> x
     plus(s(x),y) -> s(plus(p(s(x)),y))
     times(0(),y) -> 0()
     times(s(x),y) -> plus(y,times(p(s(x)),y))
     exp(x,0()) -> s(0())
     exp(x,s(y)) -> times(x,exp(x,y))
     p(s(0())) -> 0()
     p(s(s(x))) -> s(p(s(x)))
     tower(x,y) -> towerIter(x,y,s(0()))
     towerIter(0(),y,z) -> z
     towerIter(s(x),y,z) -> towerIter(p(s(x)),y,exp(y,z))
    Usable Rule Processor:
     DPs:
      plus#(s(x),y) -> plus#(p(s(x)),y)
     TRS:
      p(s(0())) -> 0()
      p(s(s(x))) -> s(p(s(x)))
     Semantic Labeling Processor:
      dimension: 2
      usable rules:
       p(s(0())) -> 0()
       p(s(s(x))) -> s(p(s(x)))
      interpretation:
                 [1 0]  
       [p](x0) = [1 0]x0,
       
                 [0 1]     [0]
       [s](x0) = [0 1]x0 + [1],
       
             [0]
       [0] = [1]
       labeled:
        plus#
        s
        p
        0
       usable (for model):
        plus#
        s
        p
        0
       argument filtering:
        pi(0) = []
        pi(s) = []
        pi(p) = []
        pi(plus#) = 0
      precedence:
       s > plus# ~ p ~ 0
      problem:
       DPs:
        
       TRS:
        p(s(0())) -> 0()
        p(s(s(x))) -> s(p(s(x)))
      Qed
    
    DPs:
     p#(s(s(x))) -> p#(s(x))
    TRS:
     plus(0(),x) -> x
     plus(s(x),y) -> s(plus(p(s(x)),y))
     times(0(),y) -> 0()
     times(s(x),y) -> plus(y,times(p(s(x)),y))
     exp(x,0()) -> s(0())
     exp(x,s(y)) -> times(x,exp(x,y))
     p(s(0())) -> 0()
     p(s(s(x))) -> s(p(s(x)))
     tower(x,y) -> towerIter(x,y,s(0()))
     towerIter(0(),y,z) -> z
     towerIter(s(x),y,z) -> towerIter(p(s(x)),y,exp(y,z))
    Subterm Criterion Processor:
     simple projection:
      pi(p#) = 0
     problem:
      DPs:
       
      TRS:
       plus(0(),x) -> x
       plus(s(x),y) -> s(plus(p(s(x)),y))
       times(0(),y) -> 0()
       times(s(x),y) -> plus(y,times(p(s(x)),y))
       exp(x,0()) -> s(0())
       exp(x,s(y)) -> times(x,exp(x,y))
       p(s(0())) -> 0()
       p(s(s(x))) -> s(p(s(x)))
       tower(x,y) -> towerIter(x,y,s(0()))
       towerIter(0(),y,z) -> z
       towerIter(s(x),y,z) -> towerIter(p(s(x)),y,exp(y,z))
     Qed