mod! R0{
  ops a b : -> Bool
  eq a = b .
  eq b = a .
}
-- The following reduction falls into infinite loop or stack overflow
-- red in R0 : a .

mod! R1{
  ops a b c : -> Bool
  eq a = b .
  eq a = c .
}
-- The following reduction returns false though b = a = c .
red in R1 : b == c .

mod! NG{
  [Zero NzNat < Nat]
  op 0 : -> Zero
  op s_ : Nat -> NzNat
  op _+_ : Nat Nat -> Nat
  op _*_ : Nat Nat -> Nat
  eq X = X + 0 .
  eq 0 = X * 0 .
}
-- The following reduction do nothing since the equations do not satisfy variable conditions
red in NG : 0 .

mod! BASIC-NAT{
  [Zero NzNat < Nat]
  op 0 : -> Zero
  op s_ : Nat -> NzNat
}

mod! NAT+{
  pr(BASIC-NAT)
  op _+_ : Nat Nat -> Nat
  vars X Y : Nat
  eq X + 0 = X .
  eq X + s Y = s(X + Y) .
}

mod! NAT*{
  pr(NAT+)
  op _*_ : Nat Nat -> Nat
  vars X Y Z : Nat
  eq X * 0 = 0 .
  eq X * s Y = X + (X * Y) .
  eq X * (Y + Z) = (X * Y) + (X * Z) .
}

mod! NAT-fact{
  pr(NAT*)
  op fact : Nat -> Nat
  var X : Nat
  eq fact(0) = s 0 .
  eq fact(s X) = s X * fact(X) .
}

mod! NAT-{
  pr(BASIC-NAT)
  op _-_ : Nat Nat -> Nat
  vars X Y : Nat
  eq X - 0 = X .
  eq 0 - Y = 0 .
  eq s X - s Y = X - Y .
}

mod! TOYAMA{
  [Nat]
  ops 0 1 : -> Nat
  op f : Nat Nat Nat -> Nat
  op g : Nat Nat -> Nat
  vars X Y : Nat
  eq f(X, 0, 1) = f(X, X, X) .
  eq g(X, Y) = X .
  eq g(X, Y) = Y .
}
mod! LOOP{
  ops a b a' b'  : -> Bool
  eq a = b .
  eq b = a .
  eq a = a' .
  eq b = b'  .
}

mod! HUET{
  [Nat]
  op 0 : -> Nat 
  op s : Nat -> Nat
  op f : Nat Nat -> Nat
  op oo : -> Nat
  var X : Nat
  eq f(X, X) = 0 .
  eq f(X, s(X)) = s(0) .
  eq oo = s(oo) .
}