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


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


YES

Problem:
 isEmpty(cons(x,xs)) -> false()
 isEmpty(nil()) -> true()
 isZero(0()) -> true()
 isZero(s(x)) -> false()
 head(cons(x,xs)) -> x
 tail(cons(x,xs)) -> xs
 tail(nil()) -> nil()
 p(s(s(x))) -> s(p(s(x)))
 p(s(0())) -> 0()
 p(0()) -> 0()
 inc(s(x)) -> s(inc(x))
 inc(0()) -> s(0())
 sumList(xs,y) -> if(isEmpty(xs),isZero(head(xs)),y,tail(xs),cons(p(head(xs)),tail(xs)),inc(y))
 if(true(),b,y,xs,ys,x) -> y
 if(false(),true(),y,xs,ys,x) -> sumList(xs,y)
 if(false(),false(),y,xs,ys,x) -> sumList(ys,x)
 sum(xs) -> sumList(xs,0())

Proof:
 DP Processor:
  DPs:
   p#(s(s(x))) -> p#(s(x))
   inc#(s(x)) -> inc#(x)
   sumList#(xs,y) -> inc#(y)
   sumList#(xs,y) -> p#(head(xs))
   sumList#(xs,y) -> tail#(xs)
   sumList#(xs,y) -> head#(xs)
   sumList#(xs,y) -> isZero#(head(xs))
   sumList#(xs,y) -> isEmpty#(xs)
   sumList#(xs,y) -> if#(isEmpty(xs),isZero(head(xs)),y,tail(xs),cons(p(head(xs)),tail(xs)),inc(y))
   if#(false(),true(),y,xs,ys,x) -> sumList#(xs,y)
   if#(false(),false(),y,xs,ys,x) -> sumList#(ys,x)
   sum#(xs) -> sumList#(xs,0())
  TRS:
   isEmpty(cons(x,xs)) -> false()
   isEmpty(nil()) -> true()
   isZero(0()) -> true()
   isZero(s(x)) -> false()
   head(cons(x,xs)) -> x
   tail(cons(x,xs)) -> xs
   tail(nil()) -> nil()
   p(s(s(x))) -> s(p(s(x)))
   p(s(0())) -> 0()
   p(0()) -> 0()
   inc(s(x)) -> s(inc(x))
   inc(0()) -> s(0())
   sumList(xs,y) -> if(isEmpty(xs),isZero(head(xs)),y,tail(xs),cons(p(head(xs)),tail(xs)),inc(y))
   if(true(),b,y,xs,ys,x) -> y
   if(false(),true(),y,xs,ys,x) -> sumList(xs,y)
   if(false(),false(),y,xs,ys,x) -> sumList(ys,x)
   sum(xs) -> sumList(xs,0())
  TDG Processor:
   DPs:
    p#(s(s(x))) -> p#(s(x))
    inc#(s(x)) -> inc#(x)
    sumList#(xs,y) -> inc#(y)
    sumList#(xs,y) -> p#(head(xs))
    sumList#(xs,y) -> tail#(xs)
    sumList#(xs,y) -> head#(xs)
    sumList#(xs,y) -> isZero#(head(xs))
    sumList#(xs,y) -> isEmpty#(xs)
    sumList#(xs,y) ->
    if#(isEmpty(xs),isZero(head(xs)),y,tail(xs),cons(p(head(xs)),tail(xs)),inc(y))
    if#(false(),true(),y,xs,ys,x) -> sumList#(xs,y)
    if#(false(),false(),y,xs,ys,x) -> sumList#(ys,x)
    sum#(xs) -> sumList#(xs,0())
   TRS:
    isEmpty(cons(x,xs)) -> false()
    isEmpty(nil()) -> true()
    isZero(0()) -> true()
    isZero(s(x)) -> false()
    head(cons(x,xs)) -> x
    tail(cons(x,xs)) -> xs
    tail(nil()) -> nil()
    p(s(s(x))) -> s(p(s(x)))
    p(s(0())) -> 0()
    p(0()) -> 0()
    inc(s(x)) -> s(inc(x))
    inc(0()) -> s(0())
    sumList(xs,y) -> if(isEmpty(xs),isZero(head(xs)),y,tail(xs),cons(p(head(xs)),tail(xs)),inc(y))
    if(true(),b,y,xs,ys,x) -> y
    if(false(),true(),y,xs,ys,x) -> sumList(xs,y)
    if(false(),false(),y,xs,ys,x) -> sumList(ys,x)
    sum(xs) -> sumList(xs,0())
   graph:
    sum#(xs) -> sumList#(xs,0()) ->
    sumList#(xs,y) ->
    if#(isEmpty(xs),isZero(head(xs)),y,tail(xs),cons(p(head(xs)),tail(xs)),inc(y))
    sum#(xs) -> sumList#(xs,0()) -> sumList#(xs,y) -> isEmpty#(xs)
    sum#(xs) -> sumList#(xs,0()) -> sumList#(xs,y) -> isZero#(head(xs))
    sum#(xs) -> sumList#(xs,0()) -> sumList#(xs,y) -> head#(xs)
    sum#(xs) -> sumList#(xs,0()) -> sumList#(xs,y) -> tail#(xs)
    sum#(xs) -> sumList#(xs,0()) -> sumList#(xs,y) -> p#(head(xs))
    sum#(xs) -> sumList#(xs,0()) ->
    sumList#(xs,y) -> inc#(y)
    if#(false(),true(),y,xs,ys,x) -> sumList#(xs,y) ->
    sumList#(xs,y) ->
    if#(isEmpty(xs),isZero(head(xs)),y,tail(xs),cons(p(head(xs)),tail(xs)),inc(y))
    if#(false(),true(),y,xs,ys,x) -> sumList#(xs,y) ->
    sumList#(xs,y) -> isEmpty#(xs)
    if#(false(),true(),y,xs,ys,x) -> sumList#(xs,y) ->
    sumList#(xs,y) -> isZero#(head(xs))
    if#(false(),true(),y,xs,ys,x) -> sumList#(xs,y) ->
    sumList#(xs,y) -> head#(xs)
    if#(false(),true(),y,xs,ys,x) -> sumList#(xs,y) ->
    sumList#(xs,y) -> tail#(xs)
    if#(false(),true(),y,xs,ys,x) -> sumList#(xs,y) ->
    sumList#(xs,y) -> p#(head(xs))
    if#(false(),true(),y,xs,ys,x) -> sumList#(xs,y) ->
    sumList#(xs,y) -> inc#(y)
    if#(false(),false(),y,xs,ys,x) -> sumList#(ys,x) ->
    sumList#(xs,y) ->
    if#(isEmpty(xs),isZero(head(xs)),y,tail(xs),cons(p(head(xs)),tail(xs)),inc(y))
    if#(false(),false(),y,xs,ys,x) -> sumList#(ys,x) ->
    sumList#(xs,y) -> isEmpty#(xs)
    if#(false(),false(),y,xs,ys,x) -> sumList#(ys,x) ->
    sumList#(xs,y) -> isZero#(head(xs))
    if#(false(),false(),y,xs,ys,x) -> sumList#(ys,x) ->
    sumList#(xs,y) -> head#(xs)
    if#(false(),false(),y,xs,ys,x) -> sumList#(ys,x) ->
    sumList#(xs,y) -> tail#(xs)
    if#(false(),false(),y,xs,ys,x) -> sumList#(ys,x) ->
    sumList#(xs,y) -> p#(head(xs))
    if#(false(),false(),y,xs,ys,x) -> sumList#(ys,x) ->
    sumList#(xs,y) -> inc#(y)
    sumList#(xs,y) ->
    if#(isEmpty(xs),isZero(head(xs)),y,tail(xs),cons(p(head(xs)),tail(xs)),inc(y)) ->
    if#(false(),false(),y,xs,ys,x) -> sumList#(ys,x)
    sumList#(xs,y) ->
    if#(isEmpty(xs),isZero(head(xs)),y,tail(xs),cons(p(head(xs)),tail(xs)),inc(y)) ->
    if#(false(),true(),y,xs,ys,x) -> sumList#(xs,y)
    sumList#(xs,y) -> inc#(y) -> inc#(s(x)) -> inc#(x)
    sumList#(xs,y) -> p#(head(xs)) -> p#(s(s(x))) -> p#(s(x))
    inc#(s(x)) -> inc#(x) -> inc#(s(x)) -> inc#(x)
    p#(s(s(x))) -> p#(s(x)) -> p#(s(s(x))) -> p#(s(x))
   SCC Processor:
    #sccs: 3
    #rules: 5
    #arcs: 27/144
    DPs:
     sumList#(xs,y) ->
     if#(isEmpty(xs),isZero(head(xs)),y,tail(xs),cons(p(head(xs)),tail(xs)),inc(y))
     if#(false(),true(),y,xs,ys,x) -> sumList#(xs,y)
     if#(false(),false(),y,xs,ys,x) -> sumList#(ys,x)
    TRS:
     isEmpty(cons(x,xs)) -> false()
     isEmpty(nil()) -> true()
     isZero(0()) -> true()
     isZero(s(x)) -> false()
     head(cons(x,xs)) -> x
     tail(cons(x,xs)) -> xs
     tail(nil()) -> nil()
     p(s(s(x))) -> s(p(s(x)))
     p(s(0())) -> 0()
     p(0()) -> 0()
     inc(s(x)) -> s(inc(x))
     inc(0()) -> s(0())
     sumList(xs,y) -> if(isEmpty(xs),isZero(head(xs)),y,tail(xs),cons(p(head(xs)),tail(xs)),inc(y))
     if(true(),b,y,xs,ys,x) -> y
     if(false(),true(),y,xs,ys,x) -> sumList(xs,y)
     if(false(),false(),y,xs,ys,x) -> sumList(ys,x)
     sum(xs) -> sumList(xs,0())
    Usable Rule Processor:
     DPs:
      sumList#(xs,y) ->
      if#(isEmpty(xs),isZero(head(xs)),y,tail(xs),cons(p(head(xs)),tail(xs)),inc(y))
      if#(false(),true(),y,xs,ys,x) -> sumList#(xs,y)
      if#(false(),false(),y,xs,ys,x) -> sumList#(ys,x)
     TRS:
      inc(s(x)) -> s(inc(x))
      inc(0()) -> s(0())
      p(s(s(x))) -> s(p(s(x)))
      p(s(0())) -> 0()
      p(0()) -> 0()
      head(cons(x,xs)) -> x
      tail(cons(x,xs)) -> xs
      tail(nil()) -> nil()
      isZero(0()) -> true()
      isZero(s(x)) -> false()
      isEmpty(cons(x,xs)) -> false()
      isEmpty(nil()) -> true()
     Arctic Interpretation Processor:
      dimension: 1
      usable rules:
       inc(s(x)) -> s(inc(x))
       inc(0()) -> s(0())
       p(s(s(x))) -> s(p(s(x)))
       p(s(0())) -> 0()
       p(0()) -> 0()
       head(cons(x,xs)) -> x
       tail(cons(x,xs)) -> xs
       tail(nil()) -> nil()
       isZero(0()) -> true()
       isZero(s(x)) -> false()
       isEmpty(cons(x,xs)) -> false()
       isEmpty(nil()) -> true()
      interpretation:
       [true] = 1,
       
       [head](x0) = 1x0,
       
       [isEmpty](x0) = -6x0 + 2,
       
       [nil] = 0,
       
       [sumList#](x0, x1) = -1x0 + 0,
       
       [if#](x0, x1, x2, x3, x4, x5) = -2x0 + x1 + x3 + -1x4 + -8x5 + 0,
       
       [0] = 6,
       
       [p](x0) = x0,
       
       [cons](x0, x1) = -1x0 + 1x1,
       
       [s](x0) = -1x0 + 7,
       
       [inc](x0) = 7,
       
       [tail](x0) = -1x0 + 0,
       
       [isZero](x0) = -5x0 + 0,
       
       [false] = 2
      orientation:
       sumList#(xs,y) = -1xs + 0 >= -1xs + 0 = if#(isEmpty(xs),isZero(head(xs)),y,tail(xs),cons(p(head(xs)),tail(xs)),inc(y))
       
       if#(false(),true(),y,xs,ys,x) = -8x + xs + -1ys + 1 >= -1xs + 0 = sumList#(xs,y)
       
       if#(false(),false(),y,xs,ys,x) = -8x + xs + -1ys + 2 >= -1ys + 0 = sumList#(ys,x)
       
       inc(s(x)) = 7 >= 7 = s(inc(x))
       
       inc(0()) = 7 >= 7 = s(0())
       
       p(s(s(x))) = -2x + 7 >= -2x + 7 = s(p(s(x)))
       
       p(s(0())) = 7 >= 6 = 0()
       
       p(0()) = 6 >= 6 = 0()
       
       head(cons(x,xs)) = x + 2xs >= x = x
       
       tail(cons(x,xs)) = -2x + xs + 0 >= xs = xs
       
       tail(nil()) = 0 >= 0 = nil()
       
       isZero(0()) = 1 >= 1 = true()
       
       isZero(s(x)) = -6x + 2 >= 2 = false()
       
       isEmpty(cons(x,xs)) = -7x + -5xs + 2 >= 2 = false()
       
       isEmpty(nil()) = 2 >= 1 = true()
      problem:
       DPs:
        sumList#(xs,y) ->
        if#(isEmpty(xs),isZero(head(xs)),y,tail(xs),cons(p(head(xs)),tail(xs)),inc(y))
        if#(false(),false(),y,xs,ys,x) -> sumList#(ys,x)
       TRS:
        inc(s(x)) -> s(inc(x))
        inc(0()) -> s(0())
        p(s(s(x))) -> s(p(s(x)))
        p(s(0())) -> 0()
        p(0()) -> 0()
        head(cons(x,xs)) -> x
        tail(cons(x,xs)) -> xs
        tail(nil()) -> nil()
        isZero(0()) -> true()
        isZero(s(x)) -> false()
        isEmpty(cons(x,xs)) -> false()
        isEmpty(nil()) -> true()
      Restore Modifier:
       DPs:
        sumList#(xs,y) ->
        if#(isEmpty(xs),isZero(head(xs)),y,tail(xs),cons(p(head(xs)),tail(xs)),inc(y))
        if#(false(),false(),y,xs,ys,x) -> sumList#(ys,x)
       TRS:
        isEmpty(cons(x,xs)) -> false()
        isEmpty(nil()) -> true()
        isZero(0()) -> true()
        isZero(s(x)) -> false()
        head(cons(x,xs)) -> x
        tail(cons(x,xs)) -> xs
        tail(nil()) -> nil()
        p(s(s(x))) -> s(p(s(x)))
        p(s(0())) -> 0()
        p(0()) -> 0()
        inc(s(x)) -> s(inc(x))
        inc(0()) -> s(0())
        sumList(xs,y) ->
        if(isEmpty(xs),isZero(head(xs)),y,tail(xs),cons(p(head(xs)),tail(xs)),inc(y))
        if(true(),b,y,xs,ys,x) -> y
        if(false(),true(),y,xs,ys,x) -> sumList(xs,y)
        if(false(),false(),y,xs,ys,x) -> sumList(ys,x)
        sum(xs) -> sumList(xs,0())
       Usable Rule Processor:
        DPs:
         sumList#(xs,y) ->
         if#(isEmpty(xs),isZero(head(xs)),y,tail(xs),cons(p(head(xs)),tail(xs)),inc(y))
         if#(false(),false(),y,xs,ys,x) -> sumList#(ys,x)
        TRS:
         inc(s(x)) -> s(inc(x))
         inc(0()) -> s(0())
         p(s(s(x))) -> s(p(s(x)))
         p(s(0())) -> 0()
         p(0()) -> 0()
         head(cons(x,xs)) -> x
         tail(cons(x,xs)) -> xs
         tail(nil()) -> nil()
         isZero(0()) -> true()
         isZero(s(x)) -> false()
         isEmpty(cons(x,xs)) -> false()
         isEmpty(nil()) -> true()
        Arctic Interpretation Processor:
         dimension: 1
         usable rules:
          p(s(s(x))) -> s(p(s(x)))
          p(s(0())) -> 0()
          p(0()) -> 0()
          head(cons(x,xs)) -> x
          isZero(0()) -> true()
          isZero(s(x)) -> false()
         interpretation:
          [true] = 0,
          
          [head](x0) = x0 + -2,
          
          [isEmpty](x0) = x0,
          
          [nil] = 2,
          
          [sumList#](x0, x1) = x0 + 1,
          
          [if#](x0, x1, x2, x3, x4, x5) = x1 + x4,
          
          [0] = 0,
          
          [p](x0) = -1x0 + 0,
          
          [cons](x0, x1) = x0 + -8,
          
          [s](x0) = 1x0 + 6,
          
          [inc](x0) = -3x0 + 2,
          
          [tail](x0) = x0,
          
          [isZero](x0) = -5x0 + 0,
          
          [false] = 1
         orientation:
          sumList#(xs,y) = xs + 1 >= -1xs + 0 = if#(isEmpty(xs),isZero(head(xs)),y,tail(xs),cons(p(head(xs)),tail(xs)),inc(y))
          
          if#(false(),false(),y,xs,ys,x) = ys + 1 >= ys + 1 = sumList#(ys,x)
          
          inc(s(x)) = -2x + 3 >= -2x + 6 = s(inc(x))
          
          inc(0()) = 2 >= 6 = s(0())
          
          p(s(s(x))) = 1x + 6 >= 1x + 6 = s(p(s(x)))
          
          p(s(0())) = 5 >= 0 = 0()
          
          p(0()) = 0 >= 0 = 0()
          
          head(cons(x,xs)) = x + -2 >= x = x
          
          tail(cons(x,xs)) = x + -8 >= xs = xs
          
          tail(nil()) = 2 >= 2 = nil()
          
          isZero(0()) = 0 >= 0 = true()
          
          isZero(s(x)) = -4x + 1 >= 1 = false()
          
          isEmpty(cons(x,xs)) = x + -8 >= 1 = false()
          
          isEmpty(nil()) = 2 >= 0 = true()
         problem:
          DPs:
           if#(false(),false(),y,xs,ys,x) -> sumList#(ys,x)
          TRS:
           inc(s(x)) -> s(inc(x))
           inc(0()) -> s(0())
           p(s(s(x))) -> s(p(s(x)))
           p(s(0())) -> 0()
           p(0()) -> 0()
           head(cons(x,xs)) -> x
           tail(cons(x,xs)) -> xs
           tail(nil()) -> nil()
           isZero(0()) -> true()
           isZero(s(x)) -> false()
           isEmpty(cons(x,xs)) -> false()
           isEmpty(nil()) -> true()
         Restore Modifier:
          DPs:
           if#(false(),false(),y,xs,ys,x) -> sumList#(ys,x)
          TRS:
           isEmpty(cons(x,xs)) -> false()
           isEmpty(nil()) -> true()
           isZero(0()) -> true()
           isZero(s(x)) -> false()
           head(cons(x,xs)) -> x
           tail(cons(x,xs)) -> xs
           tail(nil()) -> nil()
           p(s(s(x))) -> s(p(s(x)))
           p(s(0())) -> 0()
           p(0()) -> 0()
           inc(s(x)) -> s(inc(x))
           inc(0()) -> s(0())
           sumList(xs,y) ->
           if(isEmpty(xs),isZero(head(xs)),y,tail(xs),cons(p(head(xs)),tail(xs)),inc(y))
           if(true(),b,y,xs,ys,x) -> y
           if(false(),true(),y,xs,ys,x) -> sumList(xs,y)
           if(false(),false(),y,xs,ys,x) -> sumList(ys,x)
           sum(xs) -> sumList(xs,0())
          SCC Processor:
           #sccs: 0
           #rules: 0
           #arcs: 4/1
           
    
    DPs:
     p#(s(s(x))) -> p#(s(x))
    TRS:
     isEmpty(cons(x,xs)) -> false()
     isEmpty(nil()) -> true()
     isZero(0()) -> true()
     isZero(s(x)) -> false()
     head(cons(x,xs)) -> x
     tail(cons(x,xs)) -> xs
     tail(nil()) -> nil()
     p(s(s(x))) -> s(p(s(x)))
     p(s(0())) -> 0()
     p(0()) -> 0()
     inc(s(x)) -> s(inc(x))
     inc(0()) -> s(0())
     sumList(xs,y) -> if(isEmpty(xs),isZero(head(xs)),y,tail(xs),cons(p(head(xs)),tail(xs)),inc(y))
     if(true(),b,y,xs,ys,x) -> y
     if(false(),true(),y,xs,ys,x) -> sumList(xs,y)
     if(false(),false(),y,xs,ys,x) -> sumList(ys,x)
     sum(xs) -> sumList(xs,0())
    Subterm Criterion Processor:
     simple projection:
      pi(p#) = 0
     problem:
      DPs:
       
      TRS:
       isEmpty(cons(x,xs)) -> false()
       isEmpty(nil()) -> true()
       isZero(0()) -> true()
       isZero(s(x)) -> false()
       head(cons(x,xs)) -> x
       tail(cons(x,xs)) -> xs
       tail(nil()) -> nil()
       p(s(s(x))) -> s(p(s(x)))
       p(s(0())) -> 0()
       p(0()) -> 0()
       inc(s(x)) -> s(inc(x))
       inc(0()) -> s(0())
       sumList(xs,y) ->
       if(isEmpty(xs),isZero(head(xs)),y,tail(xs),cons(p(head(xs)),tail(xs)),inc(y))
       if(true(),b,y,xs,ys,x) -> y
       if(false(),true(),y,xs,ys,x) -> sumList(xs,y)
       if(false(),false(),y,xs,ys,x) -> sumList(ys,x)
       sum(xs) -> sumList(xs,0())
     Qed
    
    DPs:
     inc#(s(x)) -> inc#(x)
    TRS:
     isEmpty(cons(x,xs)) -> false()
     isEmpty(nil()) -> true()
     isZero(0()) -> true()
     isZero(s(x)) -> false()
     head(cons(x,xs)) -> x
     tail(cons(x,xs)) -> xs
     tail(nil()) -> nil()
     p(s(s(x))) -> s(p(s(x)))
     p(s(0())) -> 0()
     p(0()) -> 0()
     inc(s(x)) -> s(inc(x))
     inc(0()) -> s(0())
     sumList(xs,y) -> if(isEmpty(xs),isZero(head(xs)),y,tail(xs),cons(p(head(xs)),tail(xs)),inc(y))
     if(true(),b,y,xs,ys,x) -> y
     if(false(),true(),y,xs,ys,x) -> sumList(xs,y)
     if(false(),false(),y,xs,ys,x) -> sumList(ys,x)
     sum(xs) -> sumList(xs,0())
    Subterm Criterion Processor:
     simple projection:
      pi(inc#) = 0
     problem:
      DPs:
       
      TRS:
       isEmpty(cons(x,xs)) -> false()
       isEmpty(nil()) -> true()
       isZero(0()) -> true()
       isZero(s(x)) -> false()
       head(cons(x,xs)) -> x
       tail(cons(x,xs)) -> xs
       tail(nil()) -> nil()
       p(s(s(x))) -> s(p(s(x)))
       p(s(0())) -> 0()
       p(0()) -> 0()
       inc(s(x)) -> s(inc(x))
       inc(0()) -> s(0())
       sumList(xs,y) ->
       if(isEmpty(xs),isZero(head(xs)),y,tail(xs),cons(p(head(xs)),tail(xs)),inc(y))
       if(true(),b,y,xs,ys,x) -> y
       if(false(),true(),y,xs,ys,x) -> sumList(xs,y)
       if(false(),false(),y,xs,ys,x) -> sumList(ys,x)
       sum(xs) -> sumList(xs,0())
     Qed