too many aliases).
     | (pos m) \Rightarrow True
     | (neg m) \Rightarrow (le m n) ]].
 
+(*CSC: the URI must disappear: there is a bug now *)
+interpretation "integer 'less or equal to'" 'leq x y = (cic:/matita/Z/orders/Zle.con x y).
+(*CSC: this alias must disappear: there is a bug in the generation of the .moos *)
+alias symbol "leq" (instance 0) = "integer 'less or equal to'".
 
 definition Zlt : Z \to Z \to Prop \def
 \lambda x,y:Z.
     | (pos m) \Rightarrow True
     | (neg m) \Rightarrow (lt m n) ]].
     
+(*CSC: the URI must disappear: there is a bug now *)
+interpretation "integer 'less than'" 'lt x y = (cic:/matita/Z/orders/Zlt.con x y).
+(*CSC: this alias must disappear: there is a bug in the generation of the .moos *)
+alias symbol "lt" (instance 0) = "integer 'less than'".
+
 theorem irreflexive_Zlt: irreflexive Z Zlt.
-change with \forall x:Z. Zlt x x \to False.
+change with \forall x:Z. x < x \to False.
 intro.elim x.exact H.
-cut (Zlt (neg n) (neg n)) \to False.
+cut neg n < neg n \to False.
 apply Hcut.apply H.simplify.apply not_le_Sn_n.
-cut (Zlt (pos n) (pos n)) \to False.
+cut pos n < pos n \to False.
 apply Hcut.apply H.simplify.apply not_le_Sn_n.
 qed.
 
     | (neg m) \Rightarrow nat_compare m n ]].
 
 theorem Zlt_neg_neg_to_lt: 
-\forall n,m:nat. Zlt (neg n) (neg m) \to lt m n.
+\forall n,m:nat. neg n < neg m \to lt m n.
 intros.apply H.
 qed.
 
-theorem lt_to_Zlt_neg_neg: \forall n,m:nat.lt m n \to Zlt (neg n) (neg m). 
+theorem lt_to_Zlt_neg_neg: \forall n,m:nat.lt m n \to neg n < neg m. 
 intros.
 simplify.apply H.
 qed.
 
 theorem Zlt_pos_pos_to_lt: 
-\forall n,m:nat. Zlt (pos n) (pos m) \to lt n m.
+\forall n,m:nat. pos n < pos m \to lt n m.
 intros.apply H.
 qed.
 
-theorem lt_to_Zlt_pos_pos: \forall n,m:nat.lt n m \to Zlt (pos n) (pos m). 
+theorem lt_to_Zlt_pos_pos: \forall n,m:nat.lt n m \to pos n < pos m. 
 intros.
 simplify.apply H.
 qed.
 
 theorem Z_compare_to_Prop : 
 \forall x,y:Z. match (Z_compare x y) with
-[ LT \Rightarrow (Zlt x y)
-| EQ \Rightarrow (eq Z x y)
-| GT \Rightarrow (Zlt y x)]. 
+[ LT \Rightarrow x < y
+| EQ \Rightarrow x=y
+| GT \Rightarrow y < x]. 
 intros.
 elim x. elim y.
 simplify.apply refl_eq.
 simplify.apply eq_f.exact H.
 qed.
 
-theorem Zlt_to_Zle: \forall x,y:Z. Zlt x y \to Zle (Zsucc x) y.
+theorem Zlt_to_Zle: \forall x,y:Z. x < y \to Zsucc x \leq y.
 intros 2.elim x.
-cut (Zlt OZ y) \to (Zle (Zsucc OZ) y).
+cut OZ < y \to Zsucc OZ \leq y.
 apply Hcut. assumption.simplify.elim y.
 simplify.exact H1.
 simplify.exact H1.
 simplify.apply le_O_n.
-cut (Zlt (neg n) y) \to (Zle (Zsucc (neg n)) y).
+cut neg n < y \to Zsucc (neg n) \leq y.
 apply Hcut. assumption.elim n.
-cut (Zlt (neg O) y) \to (Zle (Zsucc (neg O)) y).
+cut neg O < y \to Zsucc (neg O) \leq y.
 apply Hcut. assumption.simplify.elim y.
 simplify.exact I.simplify.apply not_le_Sn_O n1 H2.
 simplify.exact I.
-cut (Zlt (neg (S n1)) y) \to (Zle (Zsucc (neg (S n1))) y).
+cut neg (S n1) < y \to (Zsucc (neg (S n1))) \leq y.
 apply Hcut. assumption.simplify.
 elim y.
 simplify.exact I.
 
                 | EQ \Rightarrow OZ
                 | GT \Rightarrow (neg (pred (minus m n)))]     
          | (neg n) \Rightarrow (neg (S (plus m n)))]].
+
+(*CSC: the URI must disappear: there is a bug now *)
+interpretation "integer plus" 'plus x y = (cic:/matita/Z/z/Zplus.con x y).
          
-theorem Zplus_z_OZ:  \forall z:Z. eq Z (Zplus z OZ) z.
+theorem Zplus_z_OZ:  \forall z:Z. Zplus z OZ = z.
 intro.elim z.
 simplify.reflexivity.
 simplify.reflexivity.
 
  [ true \Rightarrow false
  | false \Rightarrow true ].
 
+(*CSC: the URI must disappear: there is a bug now *)
 interpretation "boolean not" 'not x = (cic:/matita/datatypes/bool/notb.con x).
 
 definition andb : bool \to bool \to bool\def
        match b2 with [true \Rightarrow true | false \Rightarrow false]
  | false \Rightarrow false ].
 
+(*CSC: the URI must disappear: there is a bug now *)
 interpretation "boolean and" 'and x y = (cic:/matita/datatypes/bool/andb.con x y).
 
 definition orb : bool \to bool \to bool\def
        match b2 with [true \Rightarrow true | false \Rightarrow false]
  | false \Rightarrow false ].
 
+(*CSC: the URI must disappear: there is a bug now *)
 interpretation "boolean or" 'or x y = (cic:/matita/datatypes/bool/orb.con x y).
 
 definition if_then_else : bool \to Prop \to Prop \to Prop \def 
 
 definition Not: Prop \to Prop \def
 \lambda A. (A \to False).
 
+(*CSC: the URI must disappear: there is a bug now *)
 interpretation "logical not" 'not x = (cic:/matita/logic/connectives/Not.con x).
+(*CSC: this alias should disappear. It is now required because the notation for Coq is pre-loaded *)
 alias symbol "not" (instance 0) = "logical not".
 
 theorem absurd : \forall A,C:Prop. A \to \lnot A \to C.
 inductive And (A,B:Prop) : Prop \def
     conj : A \to B \to (And A B).
 
+(*CSC: the URI must disappear: there is a bug now *)
 interpretation "logical and" 'and x y = (cic:/matita/logic/connectives/And.ind#xpointer(1/1) x y).
+(*CSC: this alias should disappear. It is now required because the notation for Coq is pre-loaded *)
 alias symbol "and" (instance 0) = "logical and".
 
 theorem proj1: \forall A,B:Prop. A \land B \to A.
      or_introl : A \to (Or A B)
    | or_intror : B \to (Or A B).
 
+(*CSC: the URI must disappear: there is a bug now *)
 interpretation "logical or" 'or x y = (cic:/matita/logic/connectives/Or.ind#xpointer(1/1) x y).
+(*CSC: this alias should disappear. It is now required because the notation for Coq is pre-loaded *)
 alias symbol "or" (instance 0) = "logical or".
    
 definition decidable : Prop \to Prop \def \lambda A:Prop. A \lor \not A.
 
 inductive eq (A:Type) (x:A) : A \to Prop \def
     refl_eq : eq A x x.
 
+(*CSC: the URI must disappear: there is a bug now *)
 interpretation "leibnitz's equality"
    'eq x y = (cic:/matita/logic/equality/eq.ind#xpointer(1/1) _ x y).
+(*CSC: this alias should disappear. It is now required because the notation for Coq is pre-loaded *)
 alias symbol "eq" (instance 0) = "leibnitz's equality".
 
     
 
        [O \Rightarrow (S p)
         | (S q) \Rightarrow minus p q ]].
 
+(*CSC: the URI must disappear: there is a bug now *)
 interpretation "natural minus" 'minus x y = (cic:/matita/nat/minus/minus.con x y).
 
 theorem minus_n_O: \forall n:nat.n=n-O.
 
   | le_n : le n n
   | le_S : \forall m:nat. le n m \to le n (S m).
 
+(*CSC: the URI must disappear: there is a bug now *)
 interpretation "natural 'less or equal to'" 'leq x y = (cic:/matita/nat/orders/le.ind#xpointer(1/1) x y).
-alias symbol "leq" (instance 0) = "natural 'less or equal to'".
 
 definition lt: nat \to nat \to Prop \def
 \lambda n,m:nat.(S n) \leq m.
 
+(*CSC: the URI must disappear: there is a bug now *)
 interpretation "natural 'less than'" 'lt x y = (cic:/matita/nat/orders/lt.con x y).
 
 definition ge: nat \to nat \to Prop \def
 \lambda n,m:nat.m \leq n.
 
+(*CSC: the URI must disappear: there is a bug now *)
 interpretation "natural 'greater or equal to'" 'geq x y = (cic:/matita/nat/orders/ge.con x y).
 
 definition gt: nat \to nat \to Prop \def
 \lambda n,m:nat.m<n.
 
+(*CSC: the URI must disappear: there is a bug now *)
 interpretation "natural 'greater than'" 'gt x y = (cic:/matita/nat/orders/gt.con x y).
 
 theorem transitive_le : transitive nat le.
 
  [ O \Rightarrow m
  | (S p) \Rightarrow S (plus p m) ].
 
+(*CSC: the URI must disappear: there is a bug now *)
 interpretation "natural plus" 'plus x y = (cic:/matita/nat/plus/plus.con x y).
-alias symbol "plus" (instance 0) = "natural plus".
 
 theorem plus_n_O: \forall n:nat. n = n+O.
 intros.elim n.
 
  [ O \Rightarrow O
  | (S p) \Rightarrow (m+(times p m)) ].
 
+(*CSC: the URI must disappear: there is a bug now *)
 interpretation "natural times" 'times x y = (cic:/matita/nat/times/times.con x y).
 
 theorem times_n_O: \forall n:nat. O = n*O.