YES

Problem:
 lt(0(),s(x)) -> true()
 lt(x,0()) -> false()
 lt(s(x),s(y)) -> lt(x,y)
 logarithm(x) -> ifa(lt(0(),x),x)
 ifa(true(),x) -> help(x,1())
 ifa(false(),x) -> logZeroError()
 help(x,y) -> ifb(lt(y,x),x,y)
 ifb(true(),x,y) -> help(half(x),s(y))
 ifb(false(),x,y) -> y
 half(0()) -> 0()
 half(s(0())) -> 0()
 half(s(s(x))) -> s(half(x))

Proof:
 DP Processor:
  DPs:
   lt#(s(x),s(y)) -> lt#(x,y)
   logarithm#(x) -> lt#(0(),x)
   logarithm#(x) -> ifa#(lt(0(),x),x)
   ifa#(true(),x) -> help#(x,1())
   help#(x,y) -> lt#(y,x)
   help#(x,y) -> ifb#(lt(y,x),x,y)
   ifb#(true(),x,y) -> half#(x)
   ifb#(true(),x,y) -> help#(half(x),s(y))
   half#(s(s(x))) -> half#(x)
  TRS:
   lt(0(),s(x)) -> true()
   lt(x,0()) -> false()
   lt(s(x),s(y)) -> lt(x,y)
   logarithm(x) -> ifa(lt(0(),x),x)
   ifa(true(),x) -> help(x,1())
   ifa(false(),x) -> logZeroError()
   help(x,y) -> ifb(lt(y,x),x,y)
   ifb(true(),x,y) -> help(half(x),s(y))
   ifb(false(),x,y) -> y
   half(0()) -> 0()
   half(s(0())) -> 0()
   half(s(s(x))) -> s(half(x))
  TDG Processor:
   DPs:
    lt#(s(x),s(y)) -> lt#(x,y)
    logarithm#(x) -> lt#(0(),x)
    logarithm#(x) -> ifa#(lt(0(),x),x)
    ifa#(true(),x) -> help#(x,1())
    help#(x,y) -> lt#(y,x)
    help#(x,y) -> ifb#(lt(y,x),x,y)
    ifb#(true(),x,y) -> half#(x)
    ifb#(true(),x,y) -> help#(half(x),s(y))
    half#(s(s(x))) -> half#(x)
   TRS:
    lt(0(),s(x)) -> true()
    lt(x,0()) -> false()
    lt(s(x),s(y)) -> lt(x,y)
    logarithm(x) -> ifa(lt(0(),x),x)
    ifa(true(),x) -> help(x,1())
    ifa(false(),x) -> logZeroError()
    help(x,y) -> ifb(lt(y,x),x,y)
    ifb(true(),x,y) -> help(half(x),s(y))
    ifb(false(),x,y) -> y
    half(0()) -> 0()
    half(s(0())) -> 0()
    half(s(s(x))) -> s(half(x))
   graph:
    half#(s(s(x))) -> half#(x) -> half#(s(s(x))) -> half#(x)
    ifb#(true(),x,y) -> half#(x) ->
    half#(s(s(x))) -> half#(x)
    ifb#(true(),x,y) -> help#(half(x),s(y)) ->
    help#(x,y) -> ifb#(lt(y,x),x,y)
    ifb#(true(),x,y) -> help#(half(x),s(y)) ->
    help#(x,y) -> lt#(y,x)
    help#(x,y) -> ifb#(lt(y,x),x,y) ->
    ifb#(true(),x,y) -> help#(half(x),s(y))
    help#(x,y) -> ifb#(lt(y,x),x,y) -> ifb#(true(),x,y) -> half#(x)
    help#(x,y) -> lt#(y,x) -> lt#(s(x),s(y)) -> lt#(x,y)
    ifa#(true(),x) -> help#(x,1()) -> help#(x,y) -> ifb#(lt(y,x),x,y)
    ifa#(true(),x) -> help#(x,1()) -> help#(x,y) -> lt#(y,x)
    logarithm#(x) -> ifa#(lt(0(),x),x) -> ifa#(true(),x) -> help#(x,1())
    logarithm#(x) -> lt#(0(),x) -> lt#(s(x),s(y)) -> lt#(x,y)
    lt#(s(x),s(y)) -> lt#(x,y) -> lt#(s(x),s(y)) -> lt#(x,y)
   SCC Processor:
    #sccs: 3
    #rules: 4
    #arcs: 12/81
    DPs:
     ifb#(true(),x,y) -> help#(half(x),s(y))
     help#(x,y) -> ifb#(lt(y,x),x,y)
    TRS:
     lt(0(),s(x)) -> true()
     lt(x,0()) -> false()
     lt(s(x),s(y)) -> lt(x,y)
     logarithm(x) -> ifa(lt(0(),x),x)
     ifa(true(),x) -> help(x,1())
     ifa(false(),x) -> logZeroError()
     help(x,y) -> ifb(lt(y,x),x,y)
     ifb(true(),x,y) -> help(half(x),s(y))
     ifb(false(),x,y) -> y
     half(0()) -> 0()
     half(s(0())) -> 0()
     half(s(s(x))) -> s(half(x))
    Usable Rule Processor:
     DPs:
      ifb#(true(),x,y) -> help#(half(x),s(y))
      help#(x,y) -> ifb#(lt(y,x),x,y)
     TRS:
      half(0()) -> 0()
      half(s(0())) -> 0()
      half(s(s(x))) -> s(half(x))
      lt(0(),s(x)) -> true()
      lt(x,0()) -> false()
      lt(s(x),s(y)) -> lt(x,y)
     Matrix Interpretation Processor: dim=1
      
      usable rules:
       half(0()) -> 0()
       half(s(0())) -> 0()
       half(s(s(x))) -> s(half(x))
       lt(0(),s(x)) -> true()
       lt(x,0()) -> false()
       lt(s(x),s(y)) -> lt(x,y)
      interpretation:
       [false] = 0,
       
       [help#](x0, x1) = 2x0 + 1,
       
       [s](x0) = 2x0 + 1,
       
       [true] = 1/2,
       
       [ifb#](x0, x1, x2) = x0 + x1 + 1/2,
       
       [0] = 0,
       
       [half](x0) = 1/2x0,
       
       [lt](x0, x1) = 1/2x1
      orientation:
       ifb#(true(),x,y) = x + 1 >= x + 1 = help#(half(x),s(y))
       
       help#(x,y) = 2x + 1 >= 3/2x + 1/2 = ifb#(lt(y,x),x,y)
       
       half(0()) = 0 >= 0 = 0()
       
       half(s(0())) = 1/2 >= 0 = 0()
       
       half(s(s(x))) = 2x + 3/2 >= x + 1 = s(half(x))
       
       lt(0(),s(x)) = x + 1/2 >= 1/2 = true()
       
       lt(x,0()) = 0 >= 0 = false()
       
       lt(s(x),s(y)) = y + 1/2 >= 1/2y = lt(x,y)
      problem:
       DPs:
        ifb#(true(),x,y) -> help#(half(x),s(y))
       TRS:
        half(0()) -> 0()
        half(s(0())) -> 0()
        half(s(s(x))) -> s(half(x))
        lt(0(),s(x)) -> true()
        lt(x,0()) -> false()
        lt(s(x),s(y)) -> lt(x,y)
      Restore Modifier:
       DPs:
        ifb#(true(),x,y) -> help#(half(x),s(y))
       TRS:
        lt(0(),s(x)) -> true()
        lt(x,0()) -> false()
        lt(s(x),s(y)) -> lt(x,y)
        logarithm(x) -> ifa(lt(0(),x),x)
        ifa(true(),x) -> help(x,1())
        ifa(false(),x) -> logZeroError()
        help(x,y) -> ifb(lt(y,x),x,y)
        ifb(true(),x,y) -> help(half(x),s(y))
        ifb(false(),x,y) -> y
        half(0()) -> 0()
        half(s(0())) -> 0()
        half(s(s(x))) -> s(half(x))
       SCC Processor:
        #sccs: 0
        #rules: 0
        #arcs: 2/1
        
    
    DPs:
     lt#(s(x),s(y)) -> lt#(x,y)
    TRS:
     lt(0(),s(x)) -> true()
     lt(x,0()) -> false()
     lt(s(x),s(y)) -> lt(x,y)
     logarithm(x) -> ifa(lt(0(),x),x)
     ifa(true(),x) -> help(x,1())
     ifa(false(),x) -> logZeroError()
     help(x,y) -> ifb(lt(y,x),x,y)
     ifb(true(),x,y) -> help(half(x),s(y))
     ifb(false(),x,y) -> y
     half(0()) -> 0()
     half(s(0())) -> 0()
     half(s(s(x))) -> s(half(x))
    Subterm Criterion Processor:
     simple projection:
      pi(lt#) = 0
     problem:
      DPs:
       
      TRS:
       lt(0(),s(x)) -> true()
       lt(x,0()) -> false()
       lt(s(x),s(y)) -> lt(x,y)
       logarithm(x) -> ifa(lt(0(),x),x)
       ifa(true(),x) -> help(x,1())
       ifa(false(),x) -> logZeroError()
       help(x,y) -> ifb(lt(y,x),x,y)
       ifb(true(),x,y) -> help(half(x),s(y))
       ifb(false(),x,y) -> y
       half(0()) -> 0()
       half(s(0())) -> 0()
       half(s(s(x))) -> s(half(x))
     Qed
    
    DPs:
     half#(s(s(x))) -> half#(x)
    TRS:
     lt(0(),s(x)) -> true()
     lt(x,0()) -> false()
     lt(s(x),s(y)) -> lt(x,y)
     logarithm(x) -> ifa(lt(0(),x),x)
     ifa(true(),x) -> help(x,1())
     ifa(false(),x) -> logZeroError()
     help(x,y) -> ifb(lt(y,x),x,y)
     ifb(true(),x,y) -> help(half(x),s(y))
     ifb(false(),x,y) -> y
     half(0()) -> 0()
     half(s(0())) -> 0()
     half(s(s(x))) -> s(half(x))
    Subterm Criterion Processor:
     simple projection:
      pi(half#) = 0
     problem:
      DPs:
       
      TRS:
       lt(0(),s(x)) -> true()
       lt(x,0()) -> false()
       lt(s(x),s(y)) -> lt(x,y)
       logarithm(x) -> ifa(lt(0(),x),x)
       ifa(true(),x) -> help(x,1())
       ifa(false(),x) -> logZeroError()
       help(x,y) -> ifb(lt(y,x),x,y)
       ifb(true(),x,y) -> help(half(x),s(y))
       ifb(false(),x,y) -> y
       half(0()) -> 0()
       half(s(0())) -> 0()
       half(s(s(x))) -> s(half(x))
     Qed