YES

Problem:
 plus(0(),Y) -> Y
 plus(s(X),Y) -> s(plus(X,Y))
 min(X,0()) -> X
 min(s(X),s(Y)) -> min(X,Y)
 min(min(X,Y),Z()) -> min(X,plus(Y,Z()))
 quot(0(),s(Y)) -> 0()
 quot(s(X),s(Y)) -> s(quot(min(X,Y),s(Y)))

Proof:
 DP Processor:
  DPs:
   plus#(s(X),Y) -> plus#(X,Y)
   min#(s(X),s(Y)) -> min#(X,Y)
   min#(min(X,Y),Z()) -> plus#(Y,Z())
   min#(min(X,Y),Z()) -> min#(X,plus(Y,Z()))
   quot#(s(X),s(Y)) -> min#(X,Y)
   quot#(s(X),s(Y)) -> quot#(min(X,Y),s(Y))
  TRS:
   plus(0(),Y) -> Y
   plus(s(X),Y) -> s(plus(X,Y))
   min(X,0()) -> X
   min(s(X),s(Y)) -> min(X,Y)
   min(min(X,Y),Z()) -> min(X,plus(Y,Z()))
   quot(0(),s(Y)) -> 0()
   quot(s(X),s(Y)) -> s(quot(min(X,Y),s(Y)))
  TDG Processor:
   DPs:
    plus#(s(X),Y) -> plus#(X,Y)
    min#(s(X),s(Y)) -> min#(X,Y)
    min#(min(X,Y),Z()) -> plus#(Y,Z())
    min#(min(X,Y),Z()) -> min#(X,plus(Y,Z()))
    quot#(s(X),s(Y)) -> min#(X,Y)
    quot#(s(X),s(Y)) -> quot#(min(X,Y),s(Y))
   TRS:
    plus(0(),Y) -> Y
    plus(s(X),Y) -> s(plus(X,Y))
    min(X,0()) -> X
    min(s(X),s(Y)) -> min(X,Y)
    min(min(X,Y),Z()) -> min(X,plus(Y,Z()))
    quot(0(),s(Y)) -> 0()
    quot(s(X),s(Y)) -> s(quot(min(X,Y),s(Y)))
   graph:
    quot#(s(X),s(Y)) -> quot#(min(X,Y),s(Y)) ->
    quot#(s(X),s(Y)) -> quot#(min(X,Y),s(Y))
    quot#(s(X),s(Y)) -> quot#(min(X,Y),s(Y)) ->
    quot#(s(X),s(Y)) -> min#(X,Y)
    quot#(s(X),s(Y)) -> min#(X,Y) ->
    min#(min(X,Y),Z()) -> min#(X,plus(Y,Z()))
    quot#(s(X),s(Y)) -> min#(X,Y) ->
    min#(min(X,Y),Z()) -> plus#(Y,Z())
    quot#(s(X),s(Y)) -> min#(X,Y) ->
    min#(s(X),s(Y)) -> min#(X,Y)
    min#(min(X,Y),Z()) -> min#(X,plus(Y,Z())) ->
    min#(min(X,Y),Z()) -> min#(X,plus(Y,Z()))
    min#(min(X,Y),Z()) -> min#(X,plus(Y,Z())) ->
    min#(min(X,Y),Z()) -> plus#(Y,Z())
    min#(min(X,Y),Z()) -> min#(X,plus(Y,Z())) ->
    min#(s(X),s(Y)) -> min#(X,Y)
    min#(min(X,Y),Z()) -> plus#(Y,Z()) -> plus#(s(X),Y) -> plus#(X,Y)
    min#(s(X),s(Y)) -> min#(X,Y) ->
    min#(min(X,Y),Z()) -> min#(X,plus(Y,Z()))
    min#(s(X),s(Y)) -> min#(X,Y) -> min#(min(X,Y),Z()) -> plus#(Y,Z())
    min#(s(X),s(Y)) -> min#(X,Y) -> min#(s(X),s(Y)) -> min#(X,Y)
    plus#(s(X),Y) -> plus#(X,Y) -> plus#(s(X),Y) -> plus#(X,Y)
   SCC Processor:
    #sccs: 3
    #rules: 4
    #arcs: 13/36
    DPs:
     quot#(s(X),s(Y)) -> quot#(min(X,Y),s(Y))
    TRS:
     plus(0(),Y) -> Y
     plus(s(X),Y) -> s(plus(X,Y))
     min(X,0()) -> X
     min(s(X),s(Y)) -> min(X,Y)
     min(min(X,Y),Z()) -> min(X,plus(Y,Z()))
     quot(0(),s(Y)) -> 0()
     quot(s(X),s(Y)) -> s(quot(min(X,Y),s(Y)))
    KBO Processor:
     argument filtering:
      pi(0) = []
      pi(plus) = [0,1]
      pi(s) = [0]
      pi(min) = 0
      pi(Z) = []
      pi(quot) = [0]
      pi(quot#) = 0
     weight function:
      w0 = 1
      w(quot#) = w(quot) = w(Z) = w(s) = w(0) = 1
      w(min) = w(plus) = 0
     precedence:
      quot > plus > quot# ~ Z ~ min ~ s ~ 0
     problem:
      DPs:
       
      TRS:
       plus(0(),Y) -> Y
       plus(s(X),Y) -> s(plus(X,Y))
       min(X,0()) -> X
       min(s(X),s(Y)) -> min(X,Y)
       min(min(X,Y),Z()) -> min(X,plus(Y,Z()))
       quot(0(),s(Y)) -> 0()
       quot(s(X),s(Y)) -> s(quot(min(X,Y),s(Y)))
     Qed
    
    DPs:
     min#(s(X),s(Y)) -> min#(X,Y)
     min#(min(X,Y),Z()) -> min#(X,plus(Y,Z()))
    TRS:
     plus(0(),Y) -> Y
     plus(s(X),Y) -> s(plus(X,Y))
     min(X,0()) -> X
     min(s(X),s(Y)) -> min(X,Y)
     min(min(X,Y),Z()) -> min(X,plus(Y,Z()))
     quot(0(),s(Y)) -> 0()
     quot(s(X),s(Y)) -> s(quot(min(X,Y),s(Y)))
    Matrix Interpretation Processor: dim=1
     
     interpretation:
      [min#](x0, x1) = 2x0,
      
      [quot](x0, x1) = 2x0 + 3,
      
      [Z] = 0,
      
      [min](x0, x1) = x0 + 1,
      
      [s](x0) = x0 + 2,
      
      [plus](x0, x1) = x0 + 2x1,
      
      [0] = 2
     orientation:
      min#(s(X),s(Y)) = 2X + 4 >= 2X = min#(X,Y)
      
      min#(min(X,Y),Z()) = 2X + 2 >= 2X = min#(X,plus(Y,Z()))
      
      plus(0(),Y) = 2Y + 2 >= Y = Y
      
      plus(s(X),Y) = X + 2Y + 2 >= X + 2Y + 2 = s(plus(X,Y))
      
      min(X,0()) = X + 1 >= X = X
      
      min(s(X),s(Y)) = X + 3 >= X + 1 = min(X,Y)
      
      min(min(X,Y),Z()) = X + 2 >= X + 1 = min(X,plus(Y,Z()))
      
      quot(0(),s(Y)) = 7 >= 2 = 0()
      
      quot(s(X),s(Y)) = 2X + 7 >= 2X + 7 = s(quot(min(X,Y),s(Y)))
     problem:
      DPs:
       
      TRS:
       plus(0(),Y) -> Y
       plus(s(X),Y) -> s(plus(X,Y))
       min(X,0()) -> X
       min(s(X),s(Y)) -> min(X,Y)
       min(min(X,Y),Z()) -> min(X,plus(Y,Z()))
       quot(0(),s(Y)) -> 0()
       quot(s(X),s(Y)) -> s(quot(min(X,Y),s(Y)))
     Qed
    
    DPs:
     plus#(s(X),Y) -> plus#(X,Y)
    TRS:
     plus(0(),Y) -> Y
     plus(s(X),Y) -> s(plus(X,Y))
     min(X,0()) -> X
     min(s(X),s(Y)) -> min(X,Y)
     min(min(X,Y),Z()) -> min(X,plus(Y,Z()))
     quot(0(),s(Y)) -> 0()
     quot(s(X),s(Y)) -> s(quot(min(X,Y),s(Y)))
    KBO Processor:
     argument filtering:
      pi(0) = []
      pi(plus) = [0,1]
      pi(s) = [0]
      pi(min) = 0
      pi(Z) = []
      pi(quot) = 0
      pi(plus#) = 0
     weight function:
      w0 = 1
      w(Z) = w(min) = w(s) = w(plus) = w(0) = 1
      w(plus#) = w(quot) = 0
     precedence:
      min > Z ~ plus ~ 0 > plus# ~ quot ~ s
     problem:
      DPs:
       
      TRS:
       plus(0(),Y) -> Y
       plus(s(X),Y) -> s(plus(X,Y))
       min(X,0()) -> X
       min(s(X),s(Y)) -> min(X,Y)
       min(min(X,Y),Z()) -> min(X,plus(Y,Z()))
       quot(0(),s(Y)) -> 0()
       quot(s(X),s(Y)) -> s(quot(min(X,Y),s(Y)))
     Qed