/export/starexec/sandbox2/solver/bin/starexec_run_ttt2 /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/output/output_files


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


YES

Problem:
 ap(ap(ff(),x),x) -> ap(ap(x,ap(ff(),x)),ap(ap(cons(),x),nil()))

Proof:
 Extended Uncurrying Processor:
  application symbol: ap
  symbol table:
   nil ==> nil0/0
   cons ==> cons0/0 cons1/1 cons2/2
   ff ==> ff0/0 ff1/1 ff2/2
   
  uncurry-rules:
   ap(ff1(x1),x2) -> ff2(x1,x2)
   ap(ff0(),x1) -> ff1(x1)
   ap(cons1(x4),x5) -> cons2(x4,x5)
   ap(cons0(),x4) -> cons1(x4)
  eta-rules:
   
  problem:
   ff2(x,x) -> ap(ap(x,ff1(x)),cons2(x,nil0()))
   ap(ff1(x1),x2) -> ff2(x1,x2)
   ap(ff0(),x1) -> ff1(x1)
   ap(cons1(x4),x5) -> cons2(x4,x5)
   ap(cons0(),x4) -> cons1(x4)
  DP Processor:
   DPs:
    ff{2,#}(x,x) -> ap#(x,ff1(x))
    ff{2,#}(x,x) -> ap#(ap(x,ff1(x)),cons2(x,nil0()))
    ap#(ff1(x1),x2) -> ff{2,#}(x1,x2)
   TRS:
    ff2(x,x) -> ap(ap(x,ff1(x)),cons2(x,nil0()))
    ap(ff1(x1),x2) -> ff2(x1,x2)
    ap(ff0(),x1) -> ff1(x1)
    ap(cons1(x4),x5) -> cons2(x4,x5)
    ap(cons0(),x4) -> cons1(x4)
   TDG Processor:
    DPs:
     ff{2,#}(x,x) -> ap#(x,ff1(x))
     ff{2,#}(x,x) -> ap#(ap(x,ff1(x)),cons2(x,nil0()))
     ap#(ff1(x1),x2) -> ff{2,#}(x1,x2)
    TRS:
     ff2(x,x) -> ap(ap(x,ff1(x)),cons2(x,nil0()))
     ap(ff1(x1),x2) -> ff2(x1,x2)
     ap(ff0(),x1) -> ff1(x1)
     ap(cons1(x4),x5) -> cons2(x4,x5)
     ap(cons0(),x4) -> cons1(x4)
    graph:
     ap#(ff1(x1),x2) -> ff{2,#}(x1,x2) ->
     ff{2,#}(x,x) -> ap#(ap(x,ff1(x)),cons2(x,nil0()))
     ap#(ff1(x1),x2) -> ff{2,#}(x1,x2) ->
     ff{2,#}(x,x) -> ap#(x,ff1(x))
     ff{2,#}(x,x) -> ap#(ap(x,ff1(x)),cons2(x,nil0())) ->
     ap#(ff1(x1),x2) -> ff{2,#}(x1,x2)
     ff{2,#}(x,x) -> ap#(x,ff1(x)) -> ap#(ff1(x1),x2) -> ff{2,#}(x1,x2)
    Matrix Interpretation Processor: dim=3
     
     usable rules:
      ff2(x,x) -> ap(ap(x,ff1(x)),cons2(x,nil0()))
      ap(ff1(x1),x2) -> ff2(x1,x2)
      ap(ff0(),x1) -> ff1(x1)
      ap(cons1(x4),x5) -> cons2(x4,x5)
      ap(cons0(),x4) -> cons1(x4)
     interpretation:
              [0]
      [ff0] = [0]
              [1],
      
                    [0 0 0]     [0]
      [cons1](x0) = [0 0 1]x0 + [1]
                    [0 0 0]     [0],
      
                     [0 1 1]     [1 1 0]     [1]
      [ap](x0, x1) = [0 0 1]x0 + [0 0 1]x1 + [0]
                     [0 0 0]     [0 0 0]     [0],
      
                  [1 1 0]     [0]
      [ff1](x0) = [0 0 1]x0 + [1]
                  [0 0 0]     [0],
      
               [0]
      [nil0] = [0]
               [0],
      
                [0]
      [cons0] = [0]
                [1],
      
      [ap#](x0, x1) = [0 1 0]x0 + [0 1 1]x1,
      
      [ff{2,#}](x0, x1) = [0 1 1]x1 + [1],
      
                        [1 0 0]  
      [cons2](x0, x1) = [0 0 1]x1
                        [0 0 0]  ,
      
                      [0 0 1]     [1 0 0]     [1]
      [ff2](x0, x1) = [0 0 0]x0 + [0 0 1]x1 + [0]
                      [0 0 0]     [0 0 0]     [0]
     orientation:
      ff{2,#}(x,x) = [0 1 1]x + [1] >= [0 1 1]x + [1] = ap#(x,ff1(x))
      
      ff{2,#}(x,x) = [0 1 1]x + [1] >= [0 0 1]x = ap#(ap(x,ff1(x)),cons2(x,nil0()))
      
      ap#(ff1(x1),x2) = [0 0 1]x1 + [0 1 1]x2 + [1] >= [0 1 1]x2 + [1] = ff{2,#}(x1,x2)
      
                 [1 0 1]    [1]    [0 0 1]    [1]                                   
      ff2(x,x) = [0 0 1]x + [0] >= [0 0 0]x + [0] = ap(ap(x,ff1(x)),cons2(x,nil0()))
                 [0 0 0]    [0]    [0 0 0]    [0]                                   
      
                       [0 0 1]     [1 1 0]     [2]    [0 0 1]     [1 0 0]     [1]             
      ap(ff1(x1),x2) = [0 0 0]x1 + [0 0 1]x2 + [0] >= [0 0 0]x1 + [0 0 1]x2 + [0] = ff2(x1,x2)
                       [0 0 0]     [0 0 0]     [0]    [0 0 0]     [0 0 0]     [0]             
      
                     [1 1 0]     [2]    [1 1 0]     [0]          
      ap(ff0(),x1) = [0 0 1]x1 + [1] >= [0 0 1]x1 + [1] = ff1(x1)
                     [0 0 0]     [0]    [0 0 0]     [0]          
      
                         [0 0 1]     [1 1 0]     [2]    [1 0 0]                 
      ap(cons1(x4),x5) = [0 0 0]x4 + [0 0 1]x5 + [0] >= [0 0 1]x5 = cons2(x4,x5)
                         [0 0 0]     [0 0 0]     [0]    [0 0 0]                 
      
                       [1 1 0]     [2]    [0 0 0]     [0]            
      ap(cons0(),x4) = [0 0 1]x4 + [1] >= [0 0 1]x4 + [1] = cons1(x4)
                       [0 0 0]     [0]    [0 0 0]     [0]            
     problem:
      DPs:
       ff{2,#}(x,x) -> ap#(x,ff1(x))
       ap#(ff1(x1),x2) -> ff{2,#}(x1,x2)
      TRS:
       ff2(x,x) -> ap(ap(x,ff1(x)),cons2(x,nil0()))
       ap(ff1(x1),x2) -> ff2(x1,x2)
       ap(ff0(),x1) -> ff1(x1)
       ap(cons1(x4),x5) -> cons2(x4,x5)
       ap(cons0(),x4) -> cons1(x4)
     Restore Modifier:
      DPs:
       ff{2,#}(x,x) -> ap#(x,ff1(x))
       ap#(ff1(x1),x2) -> ff{2,#}(x1,x2)
      TRS:
       ff2(x,x) -> ap(ap(x,ff1(x)),cons2(x,nil0()))
       ap(ff1(x1),x2) -> ff2(x1,x2)
       ap(ff0(),x1) -> ff1(x1)
       ap(cons1(x4),x5) -> cons2(x4,x5)
       ap(cons0(),x4) -> cons1(x4)
      Size-Change Termination Processor:
       DPs:
        
       TRS:
        ff2(x,x) -> ap(ap(x,ff1(x)),cons2(x,nil0()))
        ap(ff1(x1),x2) -> ff2(x1,x2)
        ap(ff0(),x1) -> ff1(x1)
        ap(cons1(x4),x5) -> cons2(x4,x5)
        ap(cons0(),x4) -> cons1(x4)
       The DP: ff{2,#}(x,x) -> ap#(x,ff1(x)) has the edges:
         0 >=  0
         1 >=  0
       The DP: ap#(ff1(x1),x2) -> ff{2,#}(x1,x2) has the edges:
         0 >   0
         1 >=  1
       Qed