MAYBE
* Step 1: NaturalPI MAYBE
    + Considered Problem:
        - Strict TRS:
            goal(xs) -> subsets(xs)
            mapconsapp(x,Nil(),rest) -> rest
            mapconsapp(x',Cons(x,xs),rest) -> Cons(Cons(x',x),mapconsapp(x',xs,rest))
            notEmpty(Cons(x,xs)) -> True()
            notEmpty(Nil()) -> False()
            subsets(Cons(x,xs)) -> subsets[Ite][True][Let](Cons(x,xs),subsets(xs))
            subsets(Nil()) -> Cons(Nil(),Nil())
        - Weak TRS:
            subsets[Ite][True][Let](Cons(x,xs),subs) -> mapconsapp(x,subs,subs)
        - Signature:
            {goal/1,mapconsapp/3,notEmpty/1,subsets/1,subsets[Ite][True][Let]/2} / {Cons/2,False/0,Nil/0,True/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {goal,mapconsapp,notEmpty,subsets
            ,subsets[Ite][True][Let]} and constructors {Cons,False,Nil,True}
    + Applied Processor:
        NaturalPI {shape = Mixed 2, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just any strict-rules}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(mixed(2)):
        The following argument positions are considered usable:
          uargs(Cons) = {2},
          uargs(subsets[Ite][True][Let]) = {2}
        
        Following symbols are considered usable:
          {goal,mapconsapp,notEmpty,subsets,subsets[Ite][True][Let]}
        TcT has computed the following interpretation:
                             p(Cons) = x2               
                            p(False) = 0                
                              p(Nil) = 1                
                             p(True) = 4                
                             p(goal) = 4 + 3*x1 + 2*x1^2
                       p(mapconsapp) = x3               
                         p(notEmpty) = 5 + 2*x1 + x1^2  
                          p(subsets) = 1 + 2*x1         
          p(subsets[Ite][True][Let]) = x2               
        
        Following rules are strictly oriented:
                    goal(xs) = 4 + 3*xs + 2*xs^2
                             > 1 + 2*xs         
                             = subsets(xs)      
        
        notEmpty(Cons(x,xs)) = 5 + 2*xs + xs^2  
                             > 4                
                             = True()           
        
             notEmpty(Nil()) = 8                
                             > 0                
                             = False()          
        
              subsets(Nil()) = 3                
                             > 1                
                             = Cons(Nil(),Nil())
        
        
        Following rules are (at-least) weakly oriented:
                        mapconsapp(x,Nil(),rest) =  rest                                           
                                                 >= rest                                           
                                                 =  rest                                           
        
                  mapconsapp(x',Cons(x,xs),rest) =  rest                                           
                                                 >= rest                                           
                                                 =  Cons(Cons(x',x),mapconsapp(x',xs,rest))        
        
                             subsets(Cons(x,xs)) =  1 + 2*xs                                       
                                                 >= 1 + 2*xs                                       
                                                 =  subsets[Ite][True][Let](Cons(x,xs),subsets(xs))
        
        subsets[Ite][True][Let](Cons(x,xs),subs) =  subs                                           
                                                 >= subs                                           
                                                 =  mapconsapp(x,subs,subs)                        
        
* Step 2: Failure MAYBE
  + Considered Problem:
      - Strict TRS:
          mapconsapp(x,Nil(),rest) -> rest
          mapconsapp(x',Cons(x,xs),rest) -> Cons(Cons(x',x),mapconsapp(x',xs,rest))
          subsets(Cons(x,xs)) -> subsets[Ite][True][Let](Cons(x,xs),subsets(xs))
      - Weak TRS:
          goal(xs) -> subsets(xs)
          notEmpty(Cons(x,xs)) -> True()
          notEmpty(Nil()) -> False()
          subsets(Nil()) -> Cons(Nil(),Nil())
          subsets[Ite][True][Let](Cons(x,xs),subs) -> mapconsapp(x,subs,subs)
      - Signature:
          {goal/1,mapconsapp/3,notEmpty/1,subsets/1,subsets[Ite][True][Let]/2} / {Cons/2,False/0,Nil/0,True/0}
      - Obligation:
          innermost runtime complexity wrt. defined symbols {goal,mapconsapp,notEmpty,subsets
          ,subsets[Ite][True][Let]} and constructors {Cons,False,Nil,True}
  + Applied Processor:
      EmptyProcessor
  + Details:
      The problem is still open.
MAYBE