YES

Problem:
 le(0(),y) -> true()
 le(s(x),0()) -> false()
 le(s(x),s(y)) -> le(x,y)
 minus(x,0()) -> x
 minus(s(x),s(y)) -> minus(x,y)
 mod(0(),y) -> 0()
 mod(s(x),0()) -> 0()
 mod(s(x),s(y)) -> if_mod(le(y,x),s(x),s(y))
 if_mod(true(),x,y) -> mod(minus(x,y),y)
 if_mod(false(),s(x),s(y)) -> s(x)

Proof:
 DP Processor:
  DPs:
   le#(s(x),s(y)) -> le#(x,y)
   minus#(s(x),s(y)) -> minus#(x,y)
   mod#(s(x),s(y)) -> le#(y,x)
   mod#(s(x),s(y)) -> if_mod#(le(y,x),s(x),s(y))
   if_mod#(true(),x,y) -> minus#(x,y)
   if_mod#(true(),x,y) -> mod#(minus(x,y),y)
  TRS:
   le(0(),y) -> true()
   le(s(x),0()) -> false()
   le(s(x),s(y)) -> le(x,y)
   minus(x,0()) -> x
   minus(s(x),s(y)) -> minus(x,y)
   mod(0(),y) -> 0()
   mod(s(x),0()) -> 0()
   mod(s(x),s(y)) -> if_mod(le(y,x),s(x),s(y))
   if_mod(true(),x,y) -> mod(minus(x,y),y)
   if_mod(false(),s(x),s(y)) -> s(x)
  TDG Processor:
   DPs:
    le#(s(x),s(y)) -> le#(x,y)
    minus#(s(x),s(y)) -> minus#(x,y)
    mod#(s(x),s(y)) -> le#(y,x)
    mod#(s(x),s(y)) -> if_mod#(le(y,x),s(x),s(y))
    if_mod#(true(),x,y) -> minus#(x,y)
    if_mod#(true(),x,y) -> mod#(minus(x,y),y)
   TRS:
    le(0(),y) -> true()
    le(s(x),0()) -> false()
    le(s(x),s(y)) -> le(x,y)
    minus(x,0()) -> x
    minus(s(x),s(y)) -> minus(x,y)
    mod(0(),y) -> 0()
    mod(s(x),0()) -> 0()
    mod(s(x),s(y)) -> if_mod(le(y,x),s(x),s(y))
    if_mod(true(),x,y) -> mod(minus(x,y),y)
    if_mod(false(),s(x),s(y)) -> s(x)
   graph:
    if_mod#(true(),x,y) -> mod#(minus(x,y),y) ->
    mod#(s(x),s(y)) -> if_mod#(le(y,x),s(x),s(y))
    if_mod#(true(),x,y) -> mod#(minus(x,y),y) ->
    mod#(s(x),s(y)) -> le#(y,x)
    if_mod#(true(),x,y) -> minus#(x,y) ->
    minus#(s(x),s(y)) -> minus#(x,y)
    mod#(s(x),s(y)) -> if_mod#(le(y,x),s(x),s(y)) ->
    if_mod#(true(),x,y) -> mod#(minus(x,y),y)
    mod#(s(x),s(y)) -> if_mod#(le(y,x),s(x),s(y)) ->
    if_mod#(true(),x,y) -> minus#(x,y)
    mod#(s(x),s(y)) -> le#(y,x) -> le#(s(x),s(y)) -> le#(x,y)
    minus#(s(x),s(y)) -> minus#(x,y) -> minus#(s(x),s(y)) -> minus#(x,y)
    le#(s(x),s(y)) -> le#(x,y) -> le#(s(x),s(y)) -> le#(x,y)
   SCC Processor:
    #sccs: 3
    #rules: 4
    #arcs: 8/36
    DPs:
     if_mod#(true(),x,y) -> mod#(minus(x,y),y)
     mod#(s(x),s(y)) -> if_mod#(le(y,x),s(x),s(y))
    TRS:
     le(0(),y) -> true()
     le(s(x),0()) -> false()
     le(s(x),s(y)) -> le(x,y)
     minus(x,0()) -> x
     minus(s(x),s(y)) -> minus(x,y)
     mod(0(),y) -> 0()
     mod(s(x),0()) -> 0()
     mod(s(x),s(y)) -> if_mod(le(y,x),s(x),s(y))
     if_mod(true(),x,y) -> mod(minus(x,y),y)
     if_mod(false(),s(x),s(y)) -> s(x)
    Extended Uncurrying Processor:
     application symbol: le
     symbol table:
      if_mod# ==> if_mod{0,#}/3
      mod# ==> mod{0,#}/2
      if_mod ==> if_mod0/3
      mod ==> mod0/2
      minus ==> minus0/2
      false ==> false0/0
      s ==> s0/1 s1/2
      true ==> true0/0
      0 ==> 00/0 01/1
      
     uncurry-rules:
      le(00(),x14) -> 01(x14)
      le(s0(x17),x18) -> s1(x17,x18)
     eta-rules:
      
     problem:
      DPs:
       if_mod{0,#}(true0(),x,y) -> mod{0,#}(minus0(x,y),y)
       mod{0,#}(s0(x),s0(y)) -> if_mod{0,#}(le(y,x),s0(x),s0(y))
      TRS:
       01(y) -> true0()
       s1(x,00()) -> false0()
       s1(x,s0(y)) -> le(x,y)
       minus0(x,00()) -> x
       minus0(s0(x),s0(y)) -> minus0(x,y)
       mod0(00(),y) -> 00()
       mod0(s0(x),00()) -> 00()
       mod0(s0(x),s0(y)) -> if_mod0(le(y,x),s0(x),s0(y))
       if_mod0(true0(),x,y) -> mod0(minus0(x,y),y)
       if_mod0(false0(),s0(x),s0(y)) -> s0(x)
       le(00(),x14) -> 01(x14)
       le(s0(x17),x18) -> s1(x17,x18)
     Extended Uncurrying Processor:
      application symbol: mod{0,#}
      symbol table:
       if_mod{0,#} ==> if_mod{0,0,#}/3
       if_mod0 ==> if_mod{0,0}/3
       mod0 ==> mod{0,0}/2
       minus0 ==> minus{0,0}/2 minus0_mod{0,#}_1#/3
       false0 ==> false{0,0}/0
       s1 ==> s{1,0}/2
       s0 ==> s{0,0}/1 s0_mod{0,#}_1#/2
       true0 ==> true{0,0}/0
       01 ==> 0{1,0}/1
       00 ==> 0{0,0}/0
       le ==> le0/2
       
      uncurry-rules:
       mod{0,#}(minus{0,0}(x45,x46),x47) -> minus0_mod{0,#}_1#(x45,x46,x47)
       mod{0,#}(s{0,0}(x43),x44) -> s0_mod{0,#}_1#(x43,x44)
      eta-rules:
       mod{0,#}(minus0(x,00()),x41) -> mod{0,#}(x,x41)
       mod{0,#}(minus0(s0(x),s0(y)),x42) -> mod{0,#}(minus0(x,y),x42)
      problem:
       DPs:
        mod{0,#}(minus{0,0}(x45,x46),x47) -> minus0_mod{0,#}_1#(x45,x46,x47)
        mod{0,#}(s{0,0}(x43),x44) -> s0_mod{0,#}_1#(x43,x44)
        minus0_mod{0,#}_1#(x,0{0,0}(),x41) -> mod{0,#}(x,x41)
        minus0_mod{0,#}_1#(s{0,0}(x),s{0,0}(y),x42) -> minus0_mod{0,#}_1#(x,y,x42)
        if_mod{0,0,#}(true{0,0}(),x,y) -> minus0_mod{0,#}_1#(x,y,y)
        s0_mod{0,#}_1#(x,s{0,0}(y)) -> if_mod{0,0,#}(le0(y,x),s{0,0}(x),s{0,0}(y))
       TRS:
        0{1,0}(y) -> true{0,0}()
        s{1,0}(x,0{0,0}()) -> false{0,0}()
        s{1,0}(x,s{0,0}(y)) -> le0(x,y)
        minus{0,0}(x,0{0,0}()) -> x
        minus{0,0}(s{0,0}(x),s{0,0}(y)) -> minus{0,0}(x,y)
        mod{0,0}(0{0,0}(),y) -> 0{0,0}()
        mod{0,0}(s{0,0}(x),0{0,0}()) -> 0{0,0}()
        mod{0,0}(s{0,0}(x),s{0,0}(y)) -> if_mod{0,0}(le0(y,x),s{0,0}(x),s{0,0}(y))
        if_mod{0,0}(true{0,0}(),x,y) -> mod{0,0}(minus{0,0}(x,y),y)
        if_mod{0,0}(false{0,0}(),s{0,0}(x),s{0,0}(y)) -> s{0,0}(x)
        le0(0{0,0}(),x14) -> 0{1,0}(x14)
        le0(s{0,0}(x17),x18) -> s{1,0}(x17,x18)
      Subterm Criterion Processor:
       simple projection:
        pi(mod{0,#}) = 0
        pi(s{0,0}) = 0
        pi(s0_mod{0,#}_1#) = 0
        pi(minus0_mod{0,#}_1#) = 0
        pi(if_mod{0,0,#}) = 1
       problem:
        DPs:
         mod{0,#}(s{0,0}(x43),x44) -> s0_mod{0,#}_1#(x43,x44)
         minus0_mod{0,#}_1#(x,0{0,0}(),x41) -> mod{0,#}(x,x41)
         minus0_mod{0,#}_1#(s{0,0}(x),s{0,0}(y),x42) -> minus0_mod{0,#}_1#(x,y,x42)
         if_mod{0,0,#}(true{0,0}(),x,y) -> minus0_mod{0,#}_1#(x,y,y)
         s0_mod{0,#}_1#(x,s{0,0}(y)) -> if_mod{0,0,#}(le0(y,x),s{0,0}(x),s{0,0}(y))
        TRS:
         0{1,0}(y) -> true{0,0}()
         s{1,0}(x,0{0,0}()) -> false{0,0}()
         s{1,0}(x,s{0,0}(y)) -> le0(x,y)
         minus{0,0}(x,0{0,0}()) -> x
         minus{0,0}(s{0,0}(x),s{0,0}(y)) -> minus{0,0}(x,y)
         mod{0,0}(0{0,0}(),y) -> 0{0,0}()
         mod{0,0}(s{0,0}(x),0{0,0}()) -> 0{0,0}()
         mod{0,0}(s{0,0}(x),s{0,0}(y)) -> if_mod{0,0}(le0(y,x),s{0,0}(x),s{0,0}(y))
         if_mod{0,0}(true{0,0}(),x,y) -> mod{0,0}(minus{0,0}(x,y),y)
         if_mod{0,0}(false{0,0}(),s{0,0}(x),s{0,0}(y)) -> s{0,0}(x)
         le0(0{0,0}(),x14) -> 0{1,0}(x14)
         le0(s{0,0}(x17),x18) -> s{1,0}(x17,x18)
       Subterm Criterion Processor:
        simple projection:
         pi(mod{0,#}) = 0
         pi(s{0,0}) = [0,0]
         pi(s0_mod{0,#}_1#) = [0,0]
         pi(minus{0,0}) = [0,0]
         pi(minus0_mod{0,#}_1#) = 0
         pi(if_mod{0,0,#}) = 1
        problem:
         DPs:
          mod{0,#}(s{0,0}(x43),x44) -> s0_mod{0,#}_1#(x43,x44)
          minus0_mod{0,#}_1#(x,0{0,0}(),x41) -> mod{0,#}(x,x41)
          if_mod{0,0,#}(true{0,0}(),x,y) -> minus0_mod{0,#}_1#(x,y,y)
          s0_mod{0,#}_1#(x,s{0,0}(y)) -> if_mod{0,0,#}(le0(y,x),s{0,0}(x),s{0,0}(y))
         TRS:
          0{1,0}(y) -> true{0,0}()
          s{1,0}(x,0{0,0}()) -> false{0,0}()
          s{1,0}(x,s{0,0}(y)) -> le0(x,y)
          minus{0,0}(x,0{0,0}()) -> x
          minus{0,0}(s{0,0}(x),s{0,0}(y)) -> minus{0,0}(x,y)
          mod{0,0}(0{0,0}(),y) -> 0{0,0}()
          mod{0,0}(s{0,0}(x),0{0,0}()) -> 0{0,0}()
          mod{0,0}(s{0,0}(x),s{0,0}(y)) -> if_mod{0,0}(le0(y,x),s{0,0}(x),s{0,0}(y))
          if_mod{0,0}(true{0,0}(),x,y) -> mod{0,0}(minus{0,0}(x,y),y)
          if_mod{0,0}(false{0,0}(),s{0,0}(x),s{0,0}(y)) -> s{0,0}(x)
          le0(0{0,0}(),x14) -> 0{1,0}(x14)
          le0(s{0,0}(x17),x18) -> s{1,0}(x17,x18)
        Usable Rule Processor:
         DPs:
          mod{0,#}(s{0,0}(x43),x44) -> s0_mod{0,#}_1#(x43,x44)
          minus0_mod{0,#}_1#(x,0{0,0}(),x41) -> mod{0,#}(x,x41)
          if_mod{0,0,#}(true{0,0}(),x,y) -> minus0_mod{0,#}_1#(x,y,y)
          s0_mod{0,#}_1#(x,s{0,0}(y)) -> if_mod{0,0,#}(le0(y,x),s{0,0}(x),s{0,0}(y))
         TRS:
          le0(0{0,0}(),x14) -> 0{1,0}(x14)
          le0(s{0,0}(x17),x18) -> s{1,0}(x17,x18)
          0{1,0}(y) -> true{0,0}()
          s{1,0}(x,0{0,0}()) -> false{0,0}()
          s{1,0}(x,s{0,0}(y)) -> le0(x,y)
         Arctic Interpretation Processor:
          dimension: 1
          usable rules:
           le0(0{0,0}(),x14) -> 0{1,0}(x14)
           le0(s{0,0}(x17),x18) -> s{1,0}(x17,x18)
           0{1,0}(y) -> true{0,0}()
           s{1,0}(x,0{0,0}()) -> false{0,0}()
           s{1,0}(x,s{0,0}(y)) -> le0(x,y)
          interpretation:
           [mod{0,#}](x0, x1) = x1 + 5,
           
           [true{0,0}] = 0,
           
           [s{0,0}](x0) = 2,
           
           [minus0_mod{0,#}_1#](x0, x1, x2) = -16x0 + x1 + x2 + -16,
           
           [0{1,0}](x0) = 4,
           
           [s{1,0}](x0, x1) = 4,
           
           [false{0,0}] = 0,
           
           [le0](x0, x1) = 4,
           
           [0{0,0}] = 6,
           
           [if_mod{0,0,#}](x0, x1, x2) = x0 + 2x1 + 3x2 + 0,
           
           [s0_mod{0,#}_1#](x0, x1) = -2x1 + 5
          orientation:
           mod{0,#}(s{0,0}(x43),x44) = x44 + 5 >= -2x44 + 5 = s0_mod{0,#}_1#(x43,x44)
           
           minus0_mod{0,#}_1#(x,0{0,0}(),x41) = -16x + x41 + 6 >= x41 + 5 = mod{0,#}(x,x41)
           
           if_mod{0,0,#}(true{0,0}(),x,y) = 2x + 3y + 0 >= -16x + y + -16 = minus0_mod{0,#}_1#(x,y,y)
           
           s0_mod{0,#}_1#(x,s{0,0}(y)) = 5 >= 5 = if_mod{0,0,#}(le0(y,x),s{0,0}(x),s{0,0}(y))
           
           le0(0{0,0}(),x14) = 4 >= 4 = 0{1,0}(x14)
           
           le0(s{0,0}(x17),x18) = 4 >= 4 = s{1,0}(x17,x18)
           
           0{1,0}(y) = 4 >= 0 = true{0,0}()
           
           s{1,0}(x,0{0,0}()) = 4 >= 0 = false{0,0}()
           
           s{1,0}(x,s{0,0}(y)) = 4 >= 4 = le0(x,y)
          problem:
           DPs:
            mod{0,#}(s{0,0}(x43),x44) -> s0_mod{0,#}_1#(x43,x44)
            minus0_mod{0,#}_1#(x,0{0,0}(),x41) -> mod{0,#}(x,x41)
            s0_mod{0,#}_1#(x,s{0,0}(y)) -> if_mod{0,0,#}(le0(y,x),s{0,0}(x),s{0,0}(y))
           TRS:
            le0(0{0,0}(),x14) -> 0{1,0}(x14)
            le0(s{0,0}(x17),x18) -> s{1,0}(x17,x18)
            0{1,0}(y) -> true{0,0}()
            s{1,0}(x,0{0,0}()) -> false{0,0}()
            s{1,0}(x,s{0,0}(y)) -> le0(x,y)
          Restore Modifier:
           DPs:
            mod{0,#}(s{0,0}(x43),x44) -> s0_mod{0,#}_1#(x43,x44)
            minus0_mod{0,#}_1#(x,0{0,0}(),x41) -> mod{0,#}(x,x41)
            s0_mod{0,#}_1#(x,s{0,0}(y)) -> if_mod{0,0,#}(le0(y,x),s{0,0}(x),s{0,0}(y))
           TRS:
            0{1,0}(y) -> true{0,0}()
            s{1,0}(x,0{0,0}()) -> false{0,0}()
            s{1,0}(x,s{0,0}(y)) -> le0(x,y)
            minus{0,0}(x,0{0,0}()) -> x
            minus{0,0}(s{0,0}(x),s{0,0}(y)) -> minus{0,0}(x,y)
            mod{0,0}(0{0,0}(),y) -> 0{0,0}()
            mod{0,0}(s{0,0}(x),0{0,0}()) -> 0{0,0}()
            mod{0,0}(s{0,0}(x),s{0,0}(y)) -> if_mod{0,0}(le0(y,x),s{0,0}(x),s{0,0}(y))
            if_mod{0,0}(true{0,0}(),x,y) -> mod{0,0}(minus{0,0}(x,y),y)
            if_mod{0,0}(false{0,0}(),s{0,0}(x),s{0,0}(y)) -> s{0,0}(x)
            le0(0{0,0}(),x14) -> 0{1,0}(x14)
            le0(s{0,0}(x17),x18) -> s{1,0}(x17,x18)
           SCC Processor:
            #sccs: 0
            #rules: 0
            #arcs: 2/9
            
    
    DPs:
     minus#(s(x),s(y)) -> minus#(x,y)
    TRS:
     le(0(),y) -> true()
     le(s(x),0()) -> false()
     le(s(x),s(y)) -> le(x,y)
     minus(x,0()) -> x
     minus(s(x),s(y)) -> minus(x,y)
     mod(0(),y) -> 0()
     mod(s(x),0()) -> 0()
     mod(s(x),s(y)) -> if_mod(le(y,x),s(x),s(y))
     if_mod(true(),x,y) -> mod(minus(x,y),y)
     if_mod(false(),s(x),s(y)) -> s(x)
    Subterm Criterion Processor:
     simple projection:
      pi(minus#) = 0
     problem:
      DPs:
       
      TRS:
       le(0(),y) -> true()
       le(s(x),0()) -> false()
       le(s(x),s(y)) -> le(x,y)
       minus(x,0()) -> x
       minus(s(x),s(y)) -> minus(x,y)
       mod(0(),y) -> 0()
       mod(s(x),0()) -> 0()
       mod(s(x),s(y)) -> if_mod(le(y,x),s(x),s(y))
       if_mod(true(),x,y) -> mod(minus(x,y),y)
       if_mod(false(),s(x),s(y)) -> s(x)
     Qed
    
    DPs:
     le#(s(x),s(y)) -> le#(x,y)
    TRS:
     le(0(),y) -> true()
     le(s(x),0()) -> false()
     le(s(x),s(y)) -> le(x,y)
     minus(x,0()) -> x
     minus(s(x),s(y)) -> minus(x,y)
     mod(0(),y) -> 0()
     mod(s(x),0()) -> 0()
     mod(s(x),s(y)) -> if_mod(le(y,x),s(x),s(y))
     if_mod(true(),x,y) -> mod(minus(x,y),y)
     if_mod(false(),s(x),s(y)) -> s(x)
    Subterm Criterion Processor:
     simple projection:
      pi(le#) = 0
     problem:
      DPs:
       
      TRS:
       le(0(),y) -> true()
       le(s(x),0()) -> false()
       le(s(x),s(y)) -> le(x,y)
       minus(x,0()) -> x
       minus(s(x),s(y)) -> minus(x,y)
       mod(0(),y) -> 0()
       mod(s(x),0()) -> 0()
       mod(s(x),s(y)) -> if_mod(le(y,x),s(x),s(y))
       if_mod(true(),x,y) -> mod(minus(x,y),y)
       if_mod(false(),s(x),s(y)) -> s(x)
     Qed