YES

Problem:
 f(nil()) -> nil()
 f(.(nil(),y)) -> .(nil(),f(y))
 f(.(.(x,y),z)) -> f(.(x,.(y,z)))
 g(nil()) -> nil()
 g(.(x,nil())) -> .(g(x),nil())
 g(.(x,.(y,z))) -> g(.(.(x,y),z))

Proof:
 DP Processor:
  DPs:
   f#(.(nil(),y)) -> f#(y)
   f#(.(.(x,y),z)) -> f#(.(x,.(y,z)))
   g#(.(x,nil())) -> g#(x)
   g#(.(x,.(y,z))) -> g#(.(.(x,y),z))
  TRS:
   f(nil()) -> nil()
   f(.(nil(),y)) -> .(nil(),f(y))
   f(.(.(x,y),z)) -> f(.(x,.(y,z)))
   g(nil()) -> nil()
   g(.(x,nil())) -> .(g(x),nil())
   g(.(x,.(y,z))) -> g(.(.(x,y),z))
  Usable Rule Processor:
   DPs:
    f#(.(nil(),y)) -> f#(y)
    f#(.(.(x,y),z)) -> f#(.(x,.(y,z)))
    g#(.(x,nil())) -> g#(x)
    g#(.(x,.(y,z))) -> g#(.(.(x,y),z))
   TRS:
    
   Matrix Interpretation Processor: dim=3
    
    usable rules:
     
    interpretation:
     [g#](x0) = [0 1 0]x0,
     
     [f#](x0) = [1 0 0]x0,
     
                   [0 0 1]     [1 0 0]     [0]
     [.](x0, x1) = [0 1 0]x0 + [0 0 1]x1 + [0]
                   [0 0 1]     [1 0 1]     [1],
     
             [0]
     [nil] = [1]
             [1]
    orientation:
     f#(.(nil(),y)) = [1 0 0]y + [1] >= [1 0 0]y = f#(y)
     
     f#(.(.(x,y),z)) = [0 0 1]x + [1 0 1]y + [1 0 0]z + [1] >= [0 0 1]x + [0 0 1]y + [1 0 0]z = f#(.(x,.(y,z)))
     
     g#(.(x,nil())) = [0 1 0]x + [1] >= [0 1 0]x = g#(x)
     
     g#(.(x,.(y,z))) = [0 1 0]x + [0 0 1]y + [1 0 1]z + [1] >= [0 1 0]x + [0 0 1]y + [0 0 1]z = g#(.(.(x,y),z))
    problem:
     DPs:
      
     TRS:
      
    Qed