YES

Problem:
 active(zeros()) -> mark(cons(0(),zeros()))
 active(tail(cons(X,XS))) -> mark(XS)
 active(cons(X1,X2)) -> cons(active(X1),X2)
 active(tail(X)) -> tail(active(X))
 cons(mark(X1),X2) -> mark(cons(X1,X2))
 tail(mark(X)) -> mark(tail(X))
 proper(zeros()) -> ok(zeros())
 proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
 proper(0()) -> ok(0())
 proper(tail(X)) -> tail(proper(X))
 cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
 tail(ok(X)) -> ok(tail(X))
 top(mark(X)) -> top(proper(X))
 top(ok(X)) -> top(active(X))

Proof:
 Matrix Interpretation Processor: dim=1
  
  interpretation:
   [top](x0) = x0,
   
   [ok](x0) = x0,
   
   [proper](x0) = x0,
   
   [tail](x0) = 4x0 + 1,
   
   [mark](x0) = x0,
   
   [cons](x0, x1) = 2x0 + 2x1,
   
   [0] = 0,
   
   [active](x0) = x0,
   
   [zeros] = 0
  orientation:
   active(zeros()) = 0 >= 0 = mark(cons(0(),zeros()))
   
   active(tail(cons(X,XS))) = 8X + 8XS + 1 >= XS = mark(XS)
   
   active(cons(X1,X2)) = 2X1 + 2X2 >= 2X1 + 2X2 = cons(active(X1),X2)
   
   active(tail(X)) = 4X + 1 >= 4X + 1 = tail(active(X))
   
   cons(mark(X1),X2) = 2X1 + 2X2 >= 2X1 + 2X2 = mark(cons(X1,X2))
   
   tail(mark(X)) = 4X + 1 >= 4X + 1 = mark(tail(X))
   
   proper(zeros()) = 0 >= 0 = ok(zeros())
   
   proper(cons(X1,X2)) = 2X1 + 2X2 >= 2X1 + 2X2 = cons(proper(X1),proper(X2))
   
   proper(0()) = 0 >= 0 = ok(0())
   
   proper(tail(X)) = 4X + 1 >= 4X + 1 = tail(proper(X))
   
   cons(ok(X1),ok(X2)) = 2X1 + 2X2 >= 2X1 + 2X2 = ok(cons(X1,X2))
   
   tail(ok(X)) = 4X + 1 >= 4X + 1 = ok(tail(X))
   
   top(mark(X)) = X >= X = top(proper(X))
   
   top(ok(X)) = X >= X = top(active(X))
  problem:
   active(zeros()) -> mark(cons(0(),zeros()))
   active(cons(X1,X2)) -> cons(active(X1),X2)
   active(tail(X)) -> tail(active(X))
   cons(mark(X1),X2) -> mark(cons(X1,X2))
   tail(mark(X)) -> mark(tail(X))
   proper(zeros()) -> ok(zeros())
   proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
   proper(0()) -> ok(0())
   proper(tail(X)) -> tail(proper(X))
   cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
   tail(ok(X)) -> ok(tail(X))
   top(mark(X)) -> top(proper(X))
   top(ok(X)) -> top(active(X))
  Matrix Interpretation Processor: dim=3
   
   interpretation:
                [1 0 1]  
    [top](x0) = [0 0 1]x0
                [0 0 0]  ,
    
               [1 0 0]  
    [ok](x0) = [0 1 0]x0
               [0 1 0]  ,
    
                   [1 0 0]  
    [proper](x0) = [0 1 0]x0
                   [0 1 0]  ,
    
                 [1 0 0]     [1]
    [tail](x0) = [0 1 0]x0 + [0]
                 [0 1 0]     [0],
    
                 [1 0 0]     [0]
    [mark](x0) = [0 1 0]x0 + [1]
                 [0 1 0]     [0],
    
                     [1 1 0]     [1 0 0]  
    [cons](x0, x1) = [1 1 0]x0 + [1 0 0]x1
                     [1 0 1]     [1 0 0]  ,
    
          [0]
    [0] = [0]
          [0],
    
                   [1 0 0]  
    [active](x0) = [0 1 0]x0
                   [0 1 0]  ,
    
              [0]
    [zeros] = [1]
              [0]
   orientation:
                      [0]    [0]                          
    active(zeros()) = [1] >= [1] = mark(cons(0(),zeros()))
                      [1]    [0]                          
    
                          [1 1 0]     [1 0 0]      [1 1 0]     [1 0 0]                        
    active(cons(X1,X2)) = [1 1 0]X1 + [1 0 0]X2 >= [1 1 0]X1 + [1 0 0]X2 = cons(active(X1),X2)
                          [1 1 0]     [1 0 0]      [1 1 0]     [1 0 0]                        
    
                      [1 0 0]    [1]    [1 0 0]    [1]                  
    active(tail(X)) = [0 1 0]X + [0] >= [0 1 0]X + [0] = tail(active(X))
                      [0 1 0]    [0]    [0 1 0]    [0]                  
    
                        [1 1 0]     [1 0 0]     [1]    [1 1 0]     [1 0 0]     [0]                    
    cons(mark(X1),X2) = [1 1 0]X1 + [1 0 0]X2 + [1] >= [1 1 0]X1 + [1 0 0]X2 + [1] = mark(cons(X1,X2))
                        [1 1 0]     [1 0 0]     [0]    [1 1 0]     [1 0 0]     [0]                    
    
                    [1 0 0]    [1]    [1 0 0]    [1]                
    tail(mark(X)) = [0 1 0]X + [1] >= [0 1 0]X + [1] = mark(tail(X))
                    [0 1 0]    [1]    [0 1 0]    [0]                
    
                      [0]    [0]              
    proper(zeros()) = [1] >= [1] = ok(zeros())
                      [1]    [1]              
    
                          [1 1 0]     [1 0 0]      [1 1 0]     [1 0 0]                                
    proper(cons(X1,X2)) = [1 1 0]X1 + [1 0 0]X2 >= [1 1 0]X1 + [1 0 0]X2 = cons(proper(X1),proper(X2))
                          [1 1 0]     [1 0 0]      [1 1 0]     [1 0 0]                                
    
                  [0]    [0]          
    proper(0()) = [0] >= [0] = ok(0())
                  [0]    [0]          
    
                      [1 0 0]    [1]    [1 0 0]    [1]                  
    proper(tail(X)) = [0 1 0]X + [0] >= [0 1 0]X + [0] = tail(proper(X))
                      [0 1 0]    [0]    [0 1 0]    [0]                  
    
                          [1 1 0]     [1 0 0]      [1 1 0]     [1 0 0]                    
    cons(ok(X1),ok(X2)) = [1 1 0]X1 + [1 0 0]X2 >= [1 1 0]X1 + [1 0 0]X2 = ok(cons(X1,X2))
                          [1 1 0]     [1 0 0]      [1 1 0]     [1 0 0]                    
    
                  [1 0 0]    [1]    [1 0 0]    [1]              
    tail(ok(X)) = [0 1 0]X + [0] >= [0 1 0]X + [0] = ok(tail(X))
                  [0 1 0]    [0]    [0 1 0]    [0]              
    
                   [1 1 0]     [1 1 0]                  
    top(mark(X)) = [0 1 0]X >= [0 1 0]X = top(proper(X))
                   [0 0 0]     [0 0 0]                  
    
                 [1 1 0]     [1 1 0]                  
    top(ok(X)) = [0 1 0]X >= [0 1 0]X = top(active(X))
                 [0 0 0]     [0 0 0]                  
   problem:
    active(zeros()) -> mark(cons(0(),zeros()))
    active(cons(X1,X2)) -> cons(active(X1),X2)
    active(tail(X)) -> tail(active(X))
    tail(mark(X)) -> mark(tail(X))
    proper(zeros()) -> ok(zeros())
    proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
    proper(0()) -> ok(0())
    proper(tail(X)) -> tail(proper(X))
    cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
    tail(ok(X)) -> ok(tail(X))
    top(mark(X)) -> top(proper(X))
    top(ok(X)) -> top(active(X))
   DP Processor:
    DPs:
     active#(zeros()) -> cons#(0(),zeros())
     active#(cons(X1,X2)) -> active#(X1)
     active#(cons(X1,X2)) -> cons#(active(X1),X2)
     active#(tail(X)) -> active#(X)
     active#(tail(X)) -> tail#(active(X))
     tail#(mark(X)) -> tail#(X)
     proper#(cons(X1,X2)) -> proper#(X2)
     proper#(cons(X1,X2)) -> proper#(X1)
     proper#(cons(X1,X2)) -> cons#(proper(X1),proper(X2))
     proper#(tail(X)) -> proper#(X)
     proper#(tail(X)) -> tail#(proper(X))
     cons#(ok(X1),ok(X2)) -> cons#(X1,X2)
     tail#(ok(X)) -> tail#(X)
     top#(mark(X)) -> proper#(X)
     top#(mark(X)) -> top#(proper(X))
     top#(ok(X)) -> active#(X)
     top#(ok(X)) -> top#(active(X))
    TRS:
     active(zeros()) -> mark(cons(0(),zeros()))
     active(cons(X1,X2)) -> cons(active(X1),X2)
     active(tail(X)) -> tail(active(X))
     tail(mark(X)) -> mark(tail(X))
     proper(zeros()) -> ok(zeros())
     proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
     proper(0()) -> ok(0())
     proper(tail(X)) -> tail(proper(X))
     cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
     tail(ok(X)) -> ok(tail(X))
     top(mark(X)) -> top(proper(X))
     top(ok(X)) -> top(active(X))
    TDG Processor:
     DPs:
      active#(zeros()) -> cons#(0(),zeros())
      active#(cons(X1,X2)) -> active#(X1)
      active#(cons(X1,X2)) -> cons#(active(X1),X2)
      active#(tail(X)) -> active#(X)
      active#(tail(X)) -> tail#(active(X))
      tail#(mark(X)) -> tail#(X)
      proper#(cons(X1,X2)) -> proper#(X2)
      proper#(cons(X1,X2)) -> proper#(X1)
      proper#(cons(X1,X2)) -> cons#(proper(X1),proper(X2))
      proper#(tail(X)) -> proper#(X)
      proper#(tail(X)) -> tail#(proper(X))
      cons#(ok(X1),ok(X2)) -> cons#(X1,X2)
      tail#(ok(X)) -> tail#(X)
      top#(mark(X)) -> proper#(X)
      top#(mark(X)) -> top#(proper(X))
      top#(ok(X)) -> active#(X)
      top#(ok(X)) -> top#(active(X))
     TRS:
      active(zeros()) -> mark(cons(0(),zeros()))
      active(cons(X1,X2)) -> cons(active(X1),X2)
      active(tail(X)) -> tail(active(X))
      tail(mark(X)) -> mark(tail(X))
      proper(zeros()) -> ok(zeros())
      proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
      proper(0()) -> ok(0())
      proper(tail(X)) -> tail(proper(X))
      cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
      tail(ok(X)) -> ok(tail(X))
      top(mark(X)) -> top(proper(X))
      top(ok(X)) -> top(active(X))
     graph:
      top#(ok(X)) -> top#(active(X)) ->
      top#(ok(X)) -> top#(active(X))
      top#(ok(X)) -> top#(active(X)) -> top#(ok(X)) -> active#(X)
      top#(ok(X)) -> top#(active(X)) ->
      top#(mark(X)) -> top#(proper(X))
      top#(ok(X)) -> top#(active(X)) -> top#(mark(X)) -> proper#(X)
      top#(ok(X)) -> active#(X) -> active#(tail(X)) -> tail#(active(X))
      top#(ok(X)) -> active#(X) -> active#(tail(X)) -> active#(X)
      top#(ok(X)) -> active#(X) ->
      active#(cons(X1,X2)) -> cons#(active(X1),X2)
      top#(ok(X)) -> active#(X) -> active#(cons(X1,X2)) -> active#(X1)
      top#(ok(X)) -> active#(X) ->
      active#(zeros()) -> cons#(0(),zeros())
      top#(mark(X)) -> top#(proper(X)) ->
      top#(ok(X)) -> top#(active(X))
      top#(mark(X)) -> top#(proper(X)) -> top#(ok(X)) -> active#(X)
      top#(mark(X)) -> top#(proper(X)) ->
      top#(mark(X)) -> top#(proper(X))
      top#(mark(X)) -> top#(proper(X)) -> top#(mark(X)) -> proper#(X)
      top#(mark(X)) -> proper#(X) ->
      proper#(tail(X)) -> tail#(proper(X))
      top#(mark(X)) -> proper#(X) -> proper#(tail(X)) -> proper#(X)
      top#(mark(X)) -> proper#(X) ->
      proper#(cons(X1,X2)) -> cons#(proper(X1),proper(X2))
      top#(mark(X)) -> proper#(X) -> proper#(cons(X1,X2)) -> proper#(X1)
      top#(mark(X)) -> proper#(X) ->
      proper#(cons(X1,X2)) -> proper#(X2)
      proper#(tail(X)) -> proper#(X) ->
      proper#(tail(X)) -> tail#(proper(X))
      proper#(tail(X)) -> proper#(X) ->
      proper#(tail(X)) -> proper#(X)
      proper#(tail(X)) -> proper#(X) ->
      proper#(cons(X1,X2)) -> cons#(proper(X1),proper(X2))
      proper#(tail(X)) -> proper#(X) ->
      proper#(cons(X1,X2)) -> proper#(X1)
      proper#(tail(X)) -> proper#(X) ->
      proper#(cons(X1,X2)) -> proper#(X2)
      proper#(tail(X)) -> tail#(proper(X)) ->
      tail#(ok(X)) -> tail#(X)
      proper#(tail(X)) -> tail#(proper(X)) ->
      tail#(mark(X)) -> tail#(X)
      proper#(cons(X1,X2)) -> proper#(X2) ->
      proper#(tail(X)) -> tail#(proper(X))
      proper#(cons(X1,X2)) -> proper#(X2) ->
      proper#(tail(X)) -> proper#(X)
      proper#(cons(X1,X2)) -> proper#(X2) ->
      proper#(cons(X1,X2)) -> cons#(proper(X1),proper(X2))
      proper#(cons(X1,X2)) -> proper#(X2) ->
      proper#(cons(X1,X2)) -> proper#(X1)
      proper#(cons(X1,X2)) -> proper#(X2) ->
      proper#(cons(X1,X2)) -> proper#(X2)
      proper#(cons(X1,X2)) -> proper#(X1) ->
      proper#(tail(X)) -> tail#(proper(X))
      proper#(cons(X1,X2)) -> proper#(X1) ->
      proper#(tail(X)) -> proper#(X)
      proper#(cons(X1,X2)) -> proper#(X1) ->
      proper#(cons(X1,X2)) -> cons#(proper(X1),proper(X2))
      proper#(cons(X1,X2)) -> proper#(X1) ->
      proper#(cons(X1,X2)) -> proper#(X1)
      proper#(cons(X1,X2)) -> proper#(X1) ->
      proper#(cons(X1,X2)) -> proper#(X2)
      proper#(cons(X1,X2)) -> cons#(proper(X1),proper(X2)) ->
      cons#(ok(X1),ok(X2)) -> cons#(X1,X2)
      tail#(ok(X)) -> tail#(X) -> tail#(ok(X)) -> tail#(X)
      tail#(ok(X)) -> tail#(X) -> tail#(mark(X)) -> tail#(X)
      tail#(mark(X)) -> tail#(X) -> tail#(ok(X)) -> tail#(X)
      tail#(mark(X)) -> tail#(X) -> tail#(mark(X)) -> tail#(X)
      cons#(ok(X1),ok(X2)) -> cons#(X1,X2) ->
      cons#(ok(X1),ok(X2)) -> cons#(X1,X2)
      active#(tail(X)) -> tail#(active(X)) ->
      tail#(ok(X)) -> tail#(X)
      active#(tail(X)) -> tail#(active(X)) ->
      tail#(mark(X)) -> tail#(X)
      active#(tail(X)) -> active#(X) ->
      active#(tail(X)) -> tail#(active(X))
      active#(tail(X)) -> active#(X) ->
      active#(tail(X)) -> active#(X)
      active#(tail(X)) -> active#(X) ->
      active#(cons(X1,X2)) -> cons#(active(X1),X2)
      active#(tail(X)) -> active#(X) ->
      active#(cons(X1,X2)) -> active#(X1)
      active#(tail(X)) -> active#(X) ->
      active#(zeros()) -> cons#(0(),zeros())
      active#(cons(X1,X2)) -> cons#(active(X1),X2) ->
      cons#(ok(X1),ok(X2)) -> cons#(X1,X2)
      active#(cons(X1,X2)) -> active#(X1) ->
      active#(tail(X)) -> tail#(active(X))
      active#(cons(X1,X2)) -> active#(X1) ->
      active#(tail(X)) -> active#(X)
      active#(cons(X1,X2)) -> active#(X1) ->
      active#(cons(X1,X2)) -> cons#(active(X1),X2)
      active#(cons(X1,X2)) -> active#(X1) ->
      active#(cons(X1,X2)) -> active#(X1)
      active#(cons(X1,X2)) -> active#(X1) ->
      active#(zeros()) -> cons#(0(),zeros())
      active#(zeros()) -> cons#(0(),zeros()) -> cons#(ok(X1),ok(X2)) -> cons#(X1,X2)
     SCC Processor:
      #sccs: 5
      #rules: 10
      #arcs: 55/289
      DPs:
       top#(ok(X)) -> top#(active(X))
       top#(mark(X)) -> top#(proper(X))
      TRS:
       active(zeros()) -> mark(cons(0(),zeros()))
       active(cons(X1,X2)) -> cons(active(X1),X2)
       active(tail(X)) -> tail(active(X))
       tail(mark(X)) -> mark(tail(X))
       proper(zeros()) -> ok(zeros())
       proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
       proper(0()) -> ok(0())
       proper(tail(X)) -> tail(proper(X))
       cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
       tail(ok(X)) -> ok(tail(X))
       top(mark(X)) -> top(proper(X))
       top(ok(X)) -> top(active(X))
      Usable Rule Processor:
       DPs:
        top#(ok(X)) -> top#(active(X))
        top#(mark(X)) -> top#(proper(X))
       TRS:
        active(zeros()) -> mark(cons(0(),zeros()))
        active(cons(X1,X2)) -> cons(active(X1),X2)
        active(tail(X)) -> tail(active(X))
        cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
        tail(mark(X)) -> mark(tail(X))
        tail(ok(X)) -> ok(tail(X))
        proper(zeros()) -> ok(zeros())
        proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
        proper(0()) -> ok(0())
        proper(tail(X)) -> tail(proper(X))
       Semantic Labeling Processor:
        dimension: 1
        usable rules:
         active(zeros()) -> mark(cons(0(),zeros()))
         active(cons(X1,X2)) -> cons(active(X1),X2)
         active(tail(X)) -> tail(active(X))
         cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
         tail(mark(X)) -> mark(tail(X))
         tail(ok(X)) -> ok(tail(X))
         proper(zeros()) -> ok(zeros())
         proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
         proper(0()) -> ok(0())
         proper(tail(X)) -> tail(proper(X))
        interpretation:
         [ok](x0) = 1,
         
         [proper](x0) = x0 + 1,
         
         [tail](x0) = 0,
         
         [mark](x0) = 0,
         
         [cons](x0, x1) = 1,
         
         [0] = 0,
         
         [active](x0) = 0,
         
         [zeros] = 0
         labeled:
          zeros
          0
         usable (for model):
          zeros
          0
         argument filtering:
          pi(zeros) = []
          pi(active) = 0
          pi(0) = []
          pi(cons) = 0
          pi(mark) = [0]
          pi(tail) = 0
          pi(proper) = 0
          pi(ok) = 0
          pi(top#) = 0
        precedence:
         zeros > 0 > top# ~ ok ~ proper ~ tail ~ mark ~ cons ~ active
        problem:
         DPs:
          top#(ok(X)) -> top#(active(X))
         TRS:
          active(zeros()) -> mark(cons(0(),zeros()))
          active(cons(X1,X2)) -> cons(active(X1),X2)
          active(tail(X)) -> tail(active(X))
          cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
          tail(mark(X)) -> mark(tail(X))
          tail(ok(X)) -> ok(tail(X))
          proper(zeros()) -> ok(zeros())
          proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
          proper(0()) -> ok(0())
          proper(tail(X)) -> tail(proper(X))
        Restore Modifier:
         DPs:
          top#(ok(X)) -> top#(active(X))
         TRS:
          active(zeros()) -> mark(cons(0(),zeros()))
          active(cons(X1,X2)) -> cons(active(X1),X2)
          active(tail(X)) -> tail(active(X))
          tail(mark(X)) -> mark(tail(X))
          proper(zeros()) -> ok(zeros())
          proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
          proper(0()) -> ok(0())
          proper(tail(X)) -> tail(proper(X))
          cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
          tail(ok(X)) -> ok(tail(X))
          top(mark(X)) -> top(proper(X))
          top(ok(X)) -> top(active(X))
         Bounds Processor:
          bound: 0
          enrichment: match-dp
          automaton:
           final states: {1}
           transitions:
            f530() -> 2*
            top{#,0}(3) -> 1*
            active0(2) -> 3*
            tail0(9) -> 9*
            tail0(3) -> 3*
            cons0(8,7) -> 9*
            cons0(3,2) -> 3*
            mark0(9) -> 3*
            00() -> 8*
            zeros0() -> 7*
          problem:
           DPs:
            
           TRS:
            active(zeros()) -> mark(cons(0(),zeros()))
            active(cons(X1,X2)) -> cons(active(X1),X2)
            active(tail(X)) -> tail(active(X))
            tail(mark(X)) -> mark(tail(X))
            proper(zeros()) -> ok(zeros())
            proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
            proper(0()) -> ok(0())
            proper(tail(X)) -> tail(proper(X))
            cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
            tail(ok(X)) -> ok(tail(X))
            top(mark(X)) -> top(proper(X))
            top(ok(X)) -> top(active(X))
          Qed
      
      DPs:
       active#(cons(X1,X2)) -> active#(X1)
       active#(tail(X)) -> active#(X)
      TRS:
       active(zeros()) -> mark(cons(0(),zeros()))
       active(cons(X1,X2)) -> cons(active(X1),X2)
       active(tail(X)) -> tail(active(X))
       tail(mark(X)) -> mark(tail(X))
       proper(zeros()) -> ok(zeros())
       proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
       proper(0()) -> ok(0())
       proper(tail(X)) -> tail(proper(X))
       cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
       tail(ok(X)) -> ok(tail(X))
       top(mark(X)) -> top(proper(X))
       top(ok(X)) -> top(active(X))
      Subterm Criterion Processor:
       simple projection:
        pi(active#) = 0
       problem:
        DPs:
         
        TRS:
         active(zeros()) -> mark(cons(0(),zeros()))
         active(cons(X1,X2)) -> cons(active(X1),X2)
         active(tail(X)) -> tail(active(X))
         tail(mark(X)) -> mark(tail(X))
         proper(zeros()) -> ok(zeros())
         proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
         proper(0()) -> ok(0())
         proper(tail(X)) -> tail(proper(X))
         cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
         tail(ok(X)) -> ok(tail(X))
         top(mark(X)) -> top(proper(X))
         top(ok(X)) -> top(active(X))
       Qed
      
      DPs:
       proper#(cons(X1,X2)) -> proper#(X2)
       proper#(cons(X1,X2)) -> proper#(X1)
       proper#(tail(X)) -> proper#(X)
      TRS:
       active(zeros()) -> mark(cons(0(),zeros()))
       active(cons(X1,X2)) -> cons(active(X1),X2)
       active(tail(X)) -> tail(active(X))
       tail(mark(X)) -> mark(tail(X))
       proper(zeros()) -> ok(zeros())
       proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
       proper(0()) -> ok(0())
       proper(tail(X)) -> tail(proper(X))
       cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
       tail(ok(X)) -> ok(tail(X))
       top(mark(X)) -> top(proper(X))
       top(ok(X)) -> top(active(X))
      Subterm Criterion Processor:
       simple projection:
        pi(proper#) = 0
       problem:
        DPs:
         
        TRS:
         active(zeros()) -> mark(cons(0(),zeros()))
         active(cons(X1,X2)) -> cons(active(X1),X2)
         active(tail(X)) -> tail(active(X))
         tail(mark(X)) -> mark(tail(X))
         proper(zeros()) -> ok(zeros())
         proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
         proper(0()) -> ok(0())
         proper(tail(X)) -> tail(proper(X))
         cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
         tail(ok(X)) -> ok(tail(X))
         top(mark(X)) -> top(proper(X))
         top(ok(X)) -> top(active(X))
       Qed
      
      DPs:
       tail#(mark(X)) -> tail#(X)
       tail#(ok(X)) -> tail#(X)
      TRS:
       active(zeros()) -> mark(cons(0(),zeros()))
       active(cons(X1,X2)) -> cons(active(X1),X2)
       active(tail(X)) -> tail(active(X))
       tail(mark(X)) -> mark(tail(X))
       proper(zeros()) -> ok(zeros())
       proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
       proper(0()) -> ok(0())
       proper(tail(X)) -> tail(proper(X))
       cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
       tail(ok(X)) -> ok(tail(X))
       top(mark(X)) -> top(proper(X))
       top(ok(X)) -> top(active(X))
      Subterm Criterion Processor:
       simple projection:
        pi(tail#) = 0
       problem:
        DPs:
         
        TRS:
         active(zeros()) -> mark(cons(0(),zeros()))
         active(cons(X1,X2)) -> cons(active(X1),X2)
         active(tail(X)) -> tail(active(X))
         tail(mark(X)) -> mark(tail(X))
         proper(zeros()) -> ok(zeros())
         proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
         proper(0()) -> ok(0())
         proper(tail(X)) -> tail(proper(X))
         cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
         tail(ok(X)) -> ok(tail(X))
         top(mark(X)) -> top(proper(X))
         top(ok(X)) -> top(active(X))
       Qed
      
      DPs:
       cons#(ok(X1),ok(X2)) -> cons#(X1,X2)
      TRS:
       active(zeros()) -> mark(cons(0(),zeros()))
       active(cons(X1,X2)) -> cons(active(X1),X2)
       active(tail(X)) -> tail(active(X))
       tail(mark(X)) -> mark(tail(X))
       proper(zeros()) -> ok(zeros())
       proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
       proper(0()) -> ok(0())
       proper(tail(X)) -> tail(proper(X))
       cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
       tail(ok(X)) -> ok(tail(X))
       top(mark(X)) -> top(proper(X))
       top(ok(X)) -> top(active(X))
      Subterm Criterion Processor:
       simple projection:
        pi(cons#) = 1
       problem:
        DPs:
         
        TRS:
         active(zeros()) -> mark(cons(0(),zeros()))
         active(cons(X1,X2)) -> cons(active(X1),X2)
         active(tail(X)) -> tail(active(X))
         tail(mark(X)) -> mark(tail(X))
         proper(zeros()) -> ok(zeros())
         proper(cons(X1,X2)) -> cons(proper(X1),proper(X2))
         proper(0()) -> ok(0())
         proper(tail(X)) -> tail(proper(X))
         cons(ok(X1),ok(X2)) -> ok(cons(X1,X2))
         tail(ok(X)) -> ok(tail(X))
         top(mark(X)) -> top(proper(X))
         top(ok(X)) -> top(active(X))
       Qed