YES

Problem:
 +(0(),y) -> y
 +(s(x),y) -> s(+(x,y))
 ++(nil(),ys) -> ys
 ++(:(x,xs),ys) -> :(x,++(xs,ys))
 sum(:(x,nil())) -> :(x,nil())
 sum(:(x,:(y,xs))) -> sum(:(+(x,y),xs))
 sum(++(xs,:(x,:(y,ys)))) -> sum(++(xs,sum(:(x,:(y,ys)))))
 -(x,0()) -> x
 -(0(),s(y)) -> 0()
 -(s(x),s(y)) -> -(x,y)
 quot(0(),s(y)) -> 0()
 quot(s(x),s(y)) -> s(quot(-(x,y),s(y)))
 length(nil()) -> 0()
 length(:(x,xs)) -> s(length(xs))
 hd(:(x,xs)) -> x
 avg(xs) -> quot(hd(sum(xs)),length(xs))

Proof:
 DP Processor:
  DPs:
   +#(s(x),y) -> +#(x,y)
   ++#(:(x,xs),ys) -> ++#(xs,ys)
   sum#(:(x,:(y,xs))) -> +#(x,y)
   sum#(:(x,:(y,xs))) -> sum#(:(+(x,y),xs))
   sum#(++(xs,:(x,:(y,ys)))) -> sum#(:(x,:(y,ys)))
   sum#(++(xs,:(x,:(y,ys)))) -> ++#(xs,sum(:(x,:(y,ys))))
   sum#(++(xs,:(x,:(y,ys)))) -> sum#(++(xs,sum(:(x,:(y,ys)))))
   -#(s(x),s(y)) -> -#(x,y)
   quot#(s(x),s(y)) -> -#(x,y)
   quot#(s(x),s(y)) -> quot#(-(x,y),s(y))
   length#(:(x,xs)) -> length#(xs)
   avg#(xs) -> length#(xs)
   avg#(xs) -> sum#(xs)
   avg#(xs) -> hd#(sum(xs))
   avg#(xs) -> quot#(hd(sum(xs)),length(xs))
  TRS:
   +(0(),y) -> y
   +(s(x),y) -> s(+(x,y))
   ++(nil(),ys) -> ys
   ++(:(x,xs),ys) -> :(x,++(xs,ys))
   sum(:(x,nil())) -> :(x,nil())
   sum(:(x,:(y,xs))) -> sum(:(+(x,y),xs))
   sum(++(xs,:(x,:(y,ys)))) -> sum(++(xs,sum(:(x,:(y,ys)))))
   -(x,0()) -> x
   -(0(),s(y)) -> 0()
   -(s(x),s(y)) -> -(x,y)
   quot(0(),s(y)) -> 0()
   quot(s(x),s(y)) -> s(quot(-(x,y),s(y)))
   length(nil()) -> 0()
   length(:(x,xs)) -> s(length(xs))
   hd(:(x,xs)) -> x
   avg(xs) -> quot(hd(sum(xs)),length(xs))
  TDG Processor:
   DPs:
    +#(s(x),y) -> +#(x,y)
    ++#(:(x,xs),ys) -> ++#(xs,ys)
    sum#(:(x,:(y,xs))) -> +#(x,y)
    sum#(:(x,:(y,xs))) -> sum#(:(+(x,y),xs))
    sum#(++(xs,:(x,:(y,ys)))) -> sum#(:(x,:(y,ys)))
    sum#(++(xs,:(x,:(y,ys)))) -> ++#(xs,sum(:(x,:(y,ys))))
    sum#(++(xs,:(x,:(y,ys)))) -> sum#(++(xs,sum(:(x,:(y,ys)))))
    -#(s(x),s(y)) -> -#(x,y)
    quot#(s(x),s(y)) -> -#(x,y)
    quot#(s(x),s(y)) -> quot#(-(x,y),s(y))
    length#(:(x,xs)) -> length#(xs)
    avg#(xs) -> length#(xs)
    avg#(xs) -> sum#(xs)
    avg#(xs) -> hd#(sum(xs))
    avg#(xs) -> quot#(hd(sum(xs)),length(xs))
   TRS:
    +(0(),y) -> y
    +(s(x),y) -> s(+(x,y))
    ++(nil(),ys) -> ys
    ++(:(x,xs),ys) -> :(x,++(xs,ys))
    sum(:(x,nil())) -> :(x,nil())
    sum(:(x,:(y,xs))) -> sum(:(+(x,y),xs))
    sum(++(xs,:(x,:(y,ys)))) -> sum(++(xs,sum(:(x,:(y,ys)))))
    -(x,0()) -> x
    -(0(),s(y)) -> 0()
    -(s(x),s(y)) -> -(x,y)
    quot(0(),s(y)) -> 0()
    quot(s(x),s(y)) -> s(quot(-(x,y),s(y)))
    length(nil()) -> 0()
    length(:(x,xs)) -> s(length(xs))
    hd(:(x,xs)) -> x
    avg(xs) -> quot(hd(sum(xs)),length(xs))
   graph:
    avg#(xs) -> length#(xs) ->
    length#(:(x,xs)) -> length#(xs)
    avg#(xs) -> quot#(hd(sum(xs)),length(xs)) ->
    quot#(s(x),s(y)) -> quot#(-(x,y),s(y))
    avg#(xs) -> quot#(hd(sum(xs)),length(xs)) -> quot#(s(x),s(y)) -> -#(x,y)
    avg#(xs) -> sum#(xs) ->
    sum#(++(xs,:(x,:(y,ys)))) -> sum#(++(xs,sum(:(x,:(y,ys)))))
    avg#(xs) -> sum#(xs) ->
    sum#(++(xs,:(x,:(y,ys)))) -> ++#(xs,sum(:(x,:(y,ys))))
    avg#(xs) -> sum#(xs) -> sum#(++(xs,:(x,:(y,ys)))) -> sum#(:(x,:(y,ys)))
    avg#(xs) -> sum#(xs) -> sum#(:(x,:(y,xs))) -> sum#(:(+(x,y),xs))
    avg#(xs) -> sum#(xs) -> sum#(:(x,:(y,xs))) -> +#(x,y)
    length#(:(x,xs)) -> length#(xs) ->
    length#(:(x,xs)) -> length#(xs)
    quot#(s(x),s(y)) -> quot#(-(x,y),s(y)) ->
    quot#(s(x),s(y)) -> quot#(-(x,y),s(y))
    quot#(s(x),s(y)) -> quot#(-(x,y),s(y)) ->
    quot#(s(x),s(y)) -> -#(x,y)
    quot#(s(x),s(y)) -> -#(x,y) -> -#(s(x),s(y)) -> -#(x,y)
    -#(s(x),s(y)) -> -#(x,y) -> -#(s(x),s(y)) -> -#(x,y)
    sum#(:(x,:(y,xs))) -> sum#(:(+(x,y),xs)) ->
    sum#(++(xs,:(x,:(y,ys)))) -> sum#(++(xs,sum(:(x,:(y,ys)))))
    sum#(:(x,:(y,xs))) -> sum#(:(+(x,y),xs)) ->
    sum#(++(xs,:(x,:(y,ys)))) -> ++#(xs,sum(:(x,:(y,ys))))
    sum#(:(x,:(y,xs))) -> sum#(:(+(x,y),xs)) ->
    sum#(++(xs,:(x,:(y,ys)))) -> sum#(:(x,:(y,ys)))
    sum#(:(x,:(y,xs))) -> sum#(:(+(x,y),xs)) ->
    sum#(:(x,:(y,xs))) -> sum#(:(+(x,y),xs))
    sum#(:(x,:(y,xs))) -> sum#(:(+(x,y),xs)) ->
    sum#(:(x,:(y,xs))) -> +#(x,y)
    sum#(:(x,:(y,xs))) -> +#(x,y) ->
    +#(s(x),y) -> +#(x,y)
    sum#(++(xs,:(x,:(y,ys)))) -> sum#(:(x,:(y,ys))) ->
    sum#(++(xs,:(x,:(y,ys)))) -> sum#(++(xs,sum(:(x,:(y,ys)))))
    sum#(++(xs,:(x,:(y,ys)))) -> sum#(:(x,:(y,ys))) ->
    sum#(++(xs,:(x,:(y,ys)))) -> ++#(xs,sum(:(x,:(y,ys))))
    sum#(++(xs,:(x,:(y,ys)))) -> sum#(:(x,:(y,ys))) ->
    sum#(++(xs,:(x,:(y,ys)))) -> sum#(:(x,:(y,ys)))
    sum#(++(xs,:(x,:(y,ys)))) -> sum#(:(x,:(y,ys))) ->
    sum#(:(x,:(y,xs))) -> sum#(:(+(x,y),xs))
    sum#(++(xs,:(x,:(y,ys)))) -> sum#(:(x,:(y,ys))) ->
    sum#(:(x,:(y,xs))) -> +#(x,y)
    sum#(++(xs,:(x,:(y,ys)))) -> sum#(++(xs,sum(:(x,:(y,ys))))) ->
    sum#(++(xs,:(x,:(y,ys)))) -> sum#(++(xs,sum(:(x,:(y,ys)))))
    sum#(++(xs,:(x,:(y,ys)))) -> sum#(++(xs,sum(:(x,:(y,ys))))) ->
    sum#(++(xs,:(x,:(y,ys)))) -> ++#(xs,sum(:(x,:(y,ys))))
    sum#(++(xs,:(x,:(y,ys)))) -> sum#(++(xs,sum(:(x,:(y,ys))))) ->
    sum#(++(xs,:(x,:(y,ys)))) -> sum#(:(x,:(y,ys)))
    sum#(++(xs,:(x,:(y,ys)))) -> sum#(++(xs,sum(:(x,:(y,ys))))) ->
    sum#(:(x,:(y,xs))) -> sum#(:(+(x,y),xs))
    sum#(++(xs,:(x,:(y,ys)))) -> sum#(++(xs,sum(:(x,:(y,ys))))) ->
    sum#(:(x,:(y,xs))) -> +#(x,y)
    sum#(++(xs,:(x,:(y,ys)))) -> ++#(xs,sum(:(x,:(y,ys)))) ->
    ++#(:(x,xs),ys) -> ++#(xs,ys)
    ++#(:(x,xs),ys) -> ++#(xs,ys) -> ++#(:(x,xs),ys) -> ++#(xs,ys)
    +#(s(x),y) -> +#(x,y) -> +#(s(x),y) -> +#(x,y)
   SCC Processor:
    #sccs: 6
    #rules: 8
    #arcs: 32/225
    DPs:
     sum#(:(x,:(y,xs))) -> sum#(:(+(x,y),xs))
     sum#(++(xs,:(x,:(y,ys)))) -> sum#(:(x,:(y,ys)))
     sum#(++(xs,:(x,:(y,ys)))) -> sum#(++(xs,sum(:(x,:(y,ys)))))
    TRS:
     +(0(),y) -> y
     +(s(x),y) -> s(+(x,y))
     ++(nil(),ys) -> ys
     ++(:(x,xs),ys) -> :(x,++(xs,ys))
     sum(:(x,nil())) -> :(x,nil())
     sum(:(x,:(y,xs))) -> sum(:(+(x,y),xs))
     sum(++(xs,:(x,:(y,ys)))) -> sum(++(xs,sum(:(x,:(y,ys)))))
     -(x,0()) -> x
     -(0(),s(y)) -> 0()
     -(s(x),s(y)) -> -(x,y)
     quot(0(),s(y)) -> 0()
     quot(s(x),s(y)) -> s(quot(-(x,y),s(y)))
     length(nil()) -> 0()
     length(:(x,xs)) -> s(length(xs))
     hd(:(x,xs)) -> x
     avg(xs) -> quot(hd(sum(xs)),length(xs))
    EDG Processor:
     DPs:
      sum#(:(x,:(y,xs))) -> sum#(:(+(x,y),xs))
      sum#(++(xs,:(x,:(y,ys)))) -> sum#(:(x,:(y,ys)))
      sum#(++(xs,:(x,:(y,ys)))) -> sum#(++(xs,sum(:(x,:(y,ys)))))
     TRS:
      +(0(),y) -> y
      +(s(x),y) -> s(+(x,y))
      ++(nil(),ys) -> ys
      ++(:(x,xs),ys) -> :(x,++(xs,ys))
      sum(:(x,nil())) -> :(x,nil())
      sum(:(x,:(y,xs))) -> sum(:(+(x,y),xs))
      sum(++(xs,:(x,:(y,ys)))) -> sum(++(xs,sum(:(x,:(y,ys)))))
      -(x,0()) -> x
      -(0(),s(y)) -> 0()
      -(s(x),s(y)) -> -(x,y)
      quot(0(),s(y)) -> 0()
      quot(s(x),s(y)) -> s(quot(-(x,y),s(y)))
      length(nil()) -> 0()
      length(:(x,xs)) -> s(length(xs))
      hd(:(x,xs)) -> x
      avg(xs) -> quot(hd(sum(xs)),length(xs))
     graph:
      sum#(:(x,:(y,xs))) -> sum#(:(+(x,y),xs)) ->
      sum#(:(x,:(y,xs))) -> sum#(:(+(x,y),xs))
      sum#(++(xs,:(x,:(y,ys)))) -> sum#(:(x,:(y,ys))) ->
      sum#(:(x,:(y,xs))) -> sum#(:(+(x,y),xs))
      sum#(++(xs,:(x,:(y,ys)))) -> sum#(++(xs,sum(:(x,:(y,ys))))) ->
      sum#(:(x,:(y,xs))) -> sum#(:(+(x,y),xs))
      sum#(++(xs,:(x,:(y,ys)))) -> sum#(++(xs,sum(:(x,:(y,ys))))) ->
      sum#(++(xs,:(x,:(y,ys)))) -> sum#(:(x,:(y,ys)))
      sum#(++(xs,:(x,:(y,ys)))) -> sum#(++(xs,sum(:(x,:(y,ys))))) ->
      sum#(++(xs,:(x,:(y,ys)))) -> sum#(++(xs,sum(:(x,:(y,ys)))))
     SCC Processor:
      #sccs: 2
      #rules: 2
      #arcs: 5/9
      DPs:
       sum#(++(xs,:(x,:(y,ys)))) -> sum#(++(xs,sum(:(x,:(y,ys)))))
      TRS:
       +(0(),y) -> y
       +(s(x),y) -> s(+(x,y))
       ++(nil(),ys) -> ys
       ++(:(x,xs),ys) -> :(x,++(xs,ys))
       sum(:(x,nil())) -> :(x,nil())
       sum(:(x,:(y,xs))) -> sum(:(+(x,y),xs))
       sum(++(xs,:(x,:(y,ys)))) -> sum(++(xs,sum(:(x,:(y,ys)))))
       -(x,0()) -> x
       -(0(),s(y)) -> 0()
       -(s(x),s(y)) -> -(x,y)
       quot(0(),s(y)) -> 0()
       quot(s(x),s(y)) -> s(quot(-(x,y),s(y)))
       length(nil()) -> 0()
       length(:(x,xs)) -> s(length(xs))
       hd(:(x,xs)) -> x
       avg(xs) -> quot(hd(sum(xs)),length(xs))
      Bounds Processor:
       bound: 1
       enrichment: top-dp
       automaton:
        final states: {2}
        transitions:
         sum{#,0}(1) -> 2*
         quot0(1,1) -> 1*
         sum1(6) -> 7*
         ++1(1,7) -> 8*
         s1(14) -> 14*
         hd0(1) -> 1*
         nil1() -> 15*
         s0(1) -> 1*
         nil0() -> 1*
         :1(14,1) -> 6*
         :1(14,15) -> 7,8
         :1(1,1) -> 5*
         :1(1,5) -> 6*
         :1(1,8) -> 8*
         +1(1,1) -> 14*
         +1(14,1) -> 14*
         sum{#,1}(8) -> 2*
         ++0(1,1) -> 1*
         +0(1,1) -> 1*
         length0(1) -> 1*
         sum0(1) -> 1*
         00() -> 1*
         -0(1,1) -> 1*
         avg0(1) -> 1*
         :0(1,1) -> 1*
         7 -> 8*
         1 -> 14*
       problem:
        DPs:
         
        TRS:
         +(0(),y) -> y
         +(s(x),y) -> s(+(x,y))
         ++(nil(),ys) -> ys
         ++(:(x,xs),ys) -> :(x,++(xs,ys))
         sum(:(x,nil())) -> :(x,nil())
         sum(:(x,:(y,xs))) -> sum(:(+(x,y),xs))
         sum(++(xs,:(x,:(y,ys)))) -> sum(++(xs,sum(:(x,:(y,ys)))))
         -(x,0()) -> x
         -(0(),s(y)) -> 0()
         -(s(x),s(y)) -> -(x,y)
         quot(0(),s(y)) -> 0()
         quot(s(x),s(y)) -> s(quot(-(x,y),s(y)))
         length(nil()) -> 0()
         length(:(x,xs)) -> s(length(xs))
         hd(:(x,xs)) -> x
         avg(xs) -> quot(hd(sum(xs)),length(xs))
       Qed
      
      DPs:
       sum#(:(x,:(y,xs))) -> sum#(:(+(x,y),xs))
      TRS:
       +(0(),y) -> y
       +(s(x),y) -> s(+(x,y))
       ++(nil(),ys) -> ys
       ++(:(x,xs),ys) -> :(x,++(xs,ys))
       sum(:(x,nil())) -> :(x,nil())
       sum(:(x,:(y,xs))) -> sum(:(+(x,y),xs))
       sum(++(xs,:(x,:(y,ys)))) -> sum(++(xs,sum(:(x,:(y,ys)))))
       -(x,0()) -> x
       -(0(),s(y)) -> 0()
       -(s(x),s(y)) -> -(x,y)
       quot(0(),s(y)) -> 0()
       quot(s(x),s(y)) -> s(quot(-(x,y),s(y)))
       length(nil()) -> 0()
       length(:(x,xs)) -> s(length(xs))
       hd(:(x,xs)) -> x
       avg(xs) -> quot(hd(sum(xs)),length(xs))
      Usable Rule Processor:
       DPs:
        sum#(:(x,:(y,xs))) -> sum#(:(+(x,y),xs))
       TRS:
        +(0(),y) -> y
        +(s(x),y) -> s(+(x,y))
       Semantic Labeling Processor:
        dimension: 1
        usable rules:
         
        interpretation:
         [+](x0, x1) = x0,
         
         [:](x0, x1) = 0,
         
         [0] = 0,
         
         [s](x0) = 0
         labeled:
         usable (for model):
         argument filtering:
          pi(0) = []
          pi(+) = 0
          pi(s) = []
          pi(:) = [1]
          pi(sum#) = 0
        precedence:
         sum# ~ : ~ s ~ + ~ 0
        problem:
         DPs:
          
         TRS:
          +(0(),y) -> y
          +(s(x),y) -> s(+(x,y))
        Qed
    
    DPs:
     ++#(:(x,xs),ys) -> ++#(xs,ys)
    TRS:
     +(0(),y) -> y
     +(s(x),y) -> s(+(x,y))
     ++(nil(),ys) -> ys
     ++(:(x,xs),ys) -> :(x,++(xs,ys))
     sum(:(x,nil())) -> :(x,nil())
     sum(:(x,:(y,xs))) -> sum(:(+(x,y),xs))
     sum(++(xs,:(x,:(y,ys)))) -> sum(++(xs,sum(:(x,:(y,ys)))))
     -(x,0()) -> x
     -(0(),s(y)) -> 0()
     -(s(x),s(y)) -> -(x,y)
     quot(0(),s(y)) -> 0()
     quot(s(x),s(y)) -> s(quot(-(x,y),s(y)))
     length(nil()) -> 0()
     length(:(x,xs)) -> s(length(xs))
     hd(:(x,xs)) -> x
     avg(xs) -> quot(hd(sum(xs)),length(xs))
    Subterm Criterion Processor:
     simple projection:
      pi(++#) = 0
     problem:
      DPs:
       
      TRS:
       +(0(),y) -> y
       +(s(x),y) -> s(+(x,y))
       ++(nil(),ys) -> ys
       ++(:(x,xs),ys) -> :(x,++(xs,ys))
       sum(:(x,nil())) -> :(x,nil())
       sum(:(x,:(y,xs))) -> sum(:(+(x,y),xs))
       sum(++(xs,:(x,:(y,ys)))) -> sum(++(xs,sum(:(x,:(y,ys)))))
       -(x,0()) -> x
       -(0(),s(y)) -> 0()
       -(s(x),s(y)) -> -(x,y)
       quot(0(),s(y)) -> 0()
       quot(s(x),s(y)) -> s(quot(-(x,y),s(y)))
       length(nil()) -> 0()
       length(:(x,xs)) -> s(length(xs))
       hd(:(x,xs)) -> x
       avg(xs) -> quot(hd(sum(xs)),length(xs))
     Qed
    
    DPs:
     +#(s(x),y) -> +#(x,y)
    TRS:
     +(0(),y) -> y
     +(s(x),y) -> s(+(x,y))
     ++(nil(),ys) -> ys
     ++(:(x,xs),ys) -> :(x,++(xs,ys))
     sum(:(x,nil())) -> :(x,nil())
     sum(:(x,:(y,xs))) -> sum(:(+(x,y),xs))
     sum(++(xs,:(x,:(y,ys)))) -> sum(++(xs,sum(:(x,:(y,ys)))))
     -(x,0()) -> x
     -(0(),s(y)) -> 0()
     -(s(x),s(y)) -> -(x,y)
     quot(0(),s(y)) -> 0()
     quot(s(x),s(y)) -> s(quot(-(x,y),s(y)))
     length(nil()) -> 0()
     length(:(x,xs)) -> s(length(xs))
     hd(:(x,xs)) -> x
     avg(xs) -> quot(hd(sum(xs)),length(xs))
    Subterm Criterion Processor:
     simple projection:
      pi(+#) = 0
     problem:
      DPs:
       
      TRS:
       +(0(),y) -> y
       +(s(x),y) -> s(+(x,y))
       ++(nil(),ys) -> ys
       ++(:(x,xs),ys) -> :(x,++(xs,ys))
       sum(:(x,nil())) -> :(x,nil())
       sum(:(x,:(y,xs))) -> sum(:(+(x,y),xs))
       sum(++(xs,:(x,:(y,ys)))) -> sum(++(xs,sum(:(x,:(y,ys)))))
       -(x,0()) -> x
       -(0(),s(y)) -> 0()
       -(s(x),s(y)) -> -(x,y)
       quot(0(),s(y)) -> 0()
       quot(s(x),s(y)) -> s(quot(-(x,y),s(y)))
       length(nil()) -> 0()
       length(:(x,xs)) -> s(length(xs))
       hd(:(x,xs)) -> x
       avg(xs) -> quot(hd(sum(xs)),length(xs))
     Qed
    
    DPs:
     quot#(s(x),s(y)) -> quot#(-(x,y),s(y))
    TRS:
     +(0(),y) -> y
     +(s(x),y) -> s(+(x,y))
     ++(nil(),ys) -> ys
     ++(:(x,xs),ys) -> :(x,++(xs,ys))
     sum(:(x,nil())) -> :(x,nil())
     sum(:(x,:(y,xs))) -> sum(:(+(x,y),xs))
     sum(++(xs,:(x,:(y,ys)))) -> sum(++(xs,sum(:(x,:(y,ys)))))
     -(x,0()) -> x
     -(0(),s(y)) -> 0()
     -(s(x),s(y)) -> -(x,y)
     quot(0(),s(y)) -> 0()
     quot(s(x),s(y)) -> s(quot(-(x,y),s(y)))
     length(nil()) -> 0()
     length(:(x,xs)) -> s(length(xs))
     hd(:(x,xs)) -> x
     avg(xs) -> quot(hd(sum(xs)),length(xs))
    Subterm Criterion Processor:
     simple projection:
      pi(-) = 0
      pi(quot#) = 0
     problem:
      DPs:
       
      TRS:
       +(0(),y) -> y
       +(s(x),y) -> s(+(x,y))
       ++(nil(),ys) -> ys
       ++(:(x,xs),ys) -> :(x,++(xs,ys))
       sum(:(x,nil())) -> :(x,nil())
       sum(:(x,:(y,xs))) -> sum(:(+(x,y),xs))
       sum(++(xs,:(x,:(y,ys)))) -> sum(++(xs,sum(:(x,:(y,ys)))))
       -(x,0()) -> x
       -(0(),s(y)) -> 0()
       -(s(x),s(y)) -> -(x,y)
       quot(0(),s(y)) -> 0()
       quot(s(x),s(y)) -> s(quot(-(x,y),s(y)))
       length(nil()) -> 0()
       length(:(x,xs)) -> s(length(xs))
       hd(:(x,xs)) -> x
       avg(xs) -> quot(hd(sum(xs)),length(xs))
     Qed
    
    DPs:
     -#(s(x),s(y)) -> -#(x,y)
    TRS:
     +(0(),y) -> y
     +(s(x),y) -> s(+(x,y))
     ++(nil(),ys) -> ys
     ++(:(x,xs),ys) -> :(x,++(xs,ys))
     sum(:(x,nil())) -> :(x,nil())
     sum(:(x,:(y,xs))) -> sum(:(+(x,y),xs))
     sum(++(xs,:(x,:(y,ys)))) -> sum(++(xs,sum(:(x,:(y,ys)))))
     -(x,0()) -> x
     -(0(),s(y)) -> 0()
     -(s(x),s(y)) -> -(x,y)
     quot(0(),s(y)) -> 0()
     quot(s(x),s(y)) -> s(quot(-(x,y),s(y)))
     length(nil()) -> 0()
     length(:(x,xs)) -> s(length(xs))
     hd(:(x,xs)) -> x
     avg(xs) -> quot(hd(sum(xs)),length(xs))
    Subterm Criterion Processor:
     simple projection:
      pi(-#) = 0
     problem:
      DPs:
       
      TRS:
       +(0(),y) -> y
       +(s(x),y) -> s(+(x,y))
       ++(nil(),ys) -> ys
       ++(:(x,xs),ys) -> :(x,++(xs,ys))
       sum(:(x,nil())) -> :(x,nil())
       sum(:(x,:(y,xs))) -> sum(:(+(x,y),xs))
       sum(++(xs,:(x,:(y,ys)))) -> sum(++(xs,sum(:(x,:(y,ys)))))
       -(x,0()) -> x
       -(0(),s(y)) -> 0()
       -(s(x),s(y)) -> -(x,y)
       quot(0(),s(y)) -> 0()
       quot(s(x),s(y)) -> s(quot(-(x,y),s(y)))
       length(nil()) -> 0()
       length(:(x,xs)) -> s(length(xs))
       hd(:(x,xs)) -> x
       avg(xs) -> quot(hd(sum(xs)),length(xs))
     Qed
    
    DPs:
     length#(:(x,xs)) -> length#(xs)
    TRS:
     +(0(),y) -> y
     +(s(x),y) -> s(+(x,y))
     ++(nil(),ys) -> ys
     ++(:(x,xs),ys) -> :(x,++(xs,ys))
     sum(:(x,nil())) -> :(x,nil())
     sum(:(x,:(y,xs))) -> sum(:(+(x,y),xs))
     sum(++(xs,:(x,:(y,ys)))) -> sum(++(xs,sum(:(x,:(y,ys)))))
     -(x,0()) -> x
     -(0(),s(y)) -> 0()
     -(s(x),s(y)) -> -(x,y)
     quot(0(),s(y)) -> 0()
     quot(s(x),s(y)) -> s(quot(-(x,y),s(y)))
     length(nil()) -> 0()
     length(:(x,xs)) -> s(length(xs))
     hd(:(x,xs)) -> x
     avg(xs) -> quot(hd(sum(xs)),length(xs))
    Subterm Criterion Processor:
     simple projection:
      pi(length#) = 0
     problem:
      DPs:
       
      TRS:
       +(0(),y) -> y
       +(s(x),y) -> s(+(x,y))
       ++(nil(),ys) -> ys
       ++(:(x,xs),ys) -> :(x,++(xs,ys))
       sum(:(x,nil())) -> :(x,nil())
       sum(:(x,:(y,xs))) -> sum(:(+(x,y),xs))
       sum(++(xs,:(x,:(y,ys)))) -> sum(++(xs,sum(:(x,:(y,ys)))))
       -(x,0()) -> x
       -(0(),s(y)) -> 0()
       -(s(x),s(y)) -> -(x,y)
       quot(0(),s(y)) -> 0()
       quot(s(x),s(y)) -> s(quot(-(x,y),s(y)))
       length(nil()) -> 0()
       length(:(x,xs)) -> s(length(xs))
       hd(:(x,xs)) -> x
       avg(xs) -> quot(hd(sum(xs)),length(xs))
     Qed