X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=weblib%2Ftutorial%2Fchapter4.ma;h=cf7f4aafce387300d1191b7300a5b7bcc4ca5d4c;hb=b5f54d2815f446a999736abd0ffe80641596a5f6;hp=bb01c3e8b79c8540a774e7232379bf7ebee374b5;hpb=538cee79ad9754ad46015de1fd34a3ad808f08c7;p=helm.git

diff --git a/weblib/tutorial/chapter4.ma b/weblib/tutorial/chapter4.ma
index bb01c3e8b..cf7f4aafc 100644
--- a/weblib/tutorial/chapter4.ma
+++ b/weblib/tutorial/chapter4.ma
@@ -1,8 +1,13 @@
+include "tutorial/chapter3.ma".
 
-include "arithmetics/nat.ma".
-include "basics/list.ma".
+(* As a simple application of lists, let us now consider strings of characters 
+over a given alphabet Alpha. We shall assume to have a decidable equality between 
+characters, that is a (computable) function eqb associating a boolean value true 
+or false to each pair of characters; eqb is correct, in the sense that (eqb x y) 
+if and only if (x = y). The type Alpha of alphabets is hence defined by the 
+following record *)
 
-interpretation "iff" 'iff a b = (iff a b).  
+interpretation "iff" 'iff a b = (iff a b). 
 
 record Alpha : Type[1] ≝ { carr :> Type[0];
    eqb: carr → carr → a href="cic:/matita/basics/bool/bool.ind(1,0,0)"bool/a;
@@ -12,175 +17,177 @@ record Alpha : Type[1] ≝ { carr :> Type[0];
 notation "a == b" non associative with precedence 45 for @{ 'eqb $a $b }.
 interpretation "eqb" 'eqb a b = (eqb ? a b).
 
-definition word ≝ λS:a href="cic:/matita/tutorial/re/Alpha.ind(1,0,0)"Alpha/a.a href="cic:/matita/basics/list/list.ind(1,0,1)"list/a S.
+definition word ≝ λS: a href="cic:/matita/tutorial/chapter4/Alpha.ind(1,0,0)"Alpha/a.a href="cic:/matita/tutorial/chapter3/list.ind(1,0,1)"list/a S.
 
-inductive re (S: a href="cic:/matita/tutorial/re/Alpha.ind(1,0,0)"Alpha/a) : Type[0] ≝
-   z: re S
- | e: re S
- | s: S → re S
- | c: re S → re S → re S
- | o: re S → re S → re S
- | k: re S → re S.
+inductive re (S: a href="cic:/matita/tutorial/chapter4/Alpha.ind(1,0,0)"Alpha/a) : Type[0] ≝
+   zero: re S
+ | epsilon: re S
+ | char: S → re S
+ | concat: re S → re S → re S
+ | or: re S → re S → re S
+ | star: re S → re S.
  
-notation < "a \sup ⋇" non associative with precedence 90 for @{ 'pk $a}.
-notation > "a ^ *" non associative with precedence 90 for @{ 'pk $a}.
-interpretation "star" 'pk a = (k ? a).
-interpretation "or" 'plus a b = (o ? a b).
+(* notation < "a \sup ⋇" non associative with precedence 90 for @{ 'pk $a}. *)
+notation "a ^ *" non associative with precedence 90 for @{ 'kstar $a}.
+interpretation "star" 'kstar a = (star ? a).
+interpretation "or" 'plus a b = (or ? a b).
            
-notation "a · b" non associative with precedence 60 for @{ 'pc $a $b}.
-interpretation "cat" 'pc a b = (c ? a b).
+notation "a · b" non associative with precedence 60 for @{ 'concat $a $b}.
+interpretation "cat" 'concat a b = (concat ? a b).
 
 (* to get rid of \middot 
 coercion c  : ∀S:Alpha.∀p:re S.  re S →  re S   ≝ c  on _p : re ?  to ∀_:?.?. *)
 
-notation < "a" non associative with precedence 90 for @{ 'ps $a}.
-notation > "` term 90 a" non associative with precedence 90 for @{ 'ps $a}.
-interpretation "atom" 'ps a = (s ? a).
+(* notation < "a" non associative with precedence 90 for @{ 'ps $a}. *)
+notation "` term 90 a" non associative with precedence 90 for @{ 'atom $a}.
+interpretation "atom" 'atom a = (char ? a).
 
 notation "ϵ" non associative with precedence 90 for @{ 'epsilon }.
-interpretation "epsilon" 'epsilon = (e ?).
+interpretation "epsilon" 'epsilon = (epsilon ?).
 
-notation "∅" non associative with precedence 90 for @{ 'empty }.
-interpretation "empty" 'empty = (z ?).
+notation "∅" (* slash emptyv *) non associative with precedence 90 for @{ 'empty }.
+interpretation "empty" 'empty = (zero ?).
 
-let rec flatten (S : a href="cic:/matita/tutorial/re/Alpha.ind(1,0,0)"Alpha/a) (l : a href="cic:/matita/basics/list/list.ind(1,0,1)"list/a (a href="cic:/matita/tutorial/re/word.def(3)"word/a S)) on l : a href="cic:/matita/tutorial/re/word.def(3)"word/a S ≝ 
+let rec flatten (S : a href="cic:/matita/tutorial/chapter4/Alpha.ind(1,0,0)"Alpha/a) (l : a href="cic:/matita/tutorial/chapter3/list.ind(1,0,1)"list/a (a href="cic:/matita/tutorial/chapter4/word.def(3)"word/a S)) on l : a href="cic:/matita/tutorial/chapter4/word.def(3)"word/a S ≝ 
 match l with [ nil ⇒ a title="nil" href="cic:/fakeuri.def(1)"[/a ] | cons w tl ⇒ w a title="append" href="cic:/fakeuri.def(1)"@/a flatten ? tl ].
 
-let rec conjunct (S : a href="cic:/matita/tutorial/re/Alpha.ind(1,0,0)"Alpha/a) (l : a href="cic:/matita/basics/list/list.ind(1,0,1)"list/a (a href="cic:/matita/tutorial/re/word.def(3)"word/a S)) (r : a href="cic:/matita/tutorial/re/word.def(3)"word/a S → Prop) on l: Prop ≝
-match l with [ nil ⇒ a href="cic:/matita/basics/logic/True.ind(1,0,0)"True/a | cons w tl ⇒ r w a title="logical and" href="cic:/fakeuri.def(1)"∧/a conjunct ? tl r ]. 
+let rec conjunct (S : a href="cic:/matita/tutorial/chapter4/Alpha.ind(1,0,0)"Alpha/a) (l : a href="cic:/matita/tutorial/chapter3/list.ind(1,0,1)"list/a (a href="cic:/matita/tutorial/chapter4/word.def(3)"word/a S)) (L :a href="cic:/matita/tutorial/chapter4/word.def(3)"word/a S → Prop) on l: Prop ≝
+match l with [ nil ⇒ a href="cic:/matita/basics/logic/True.ind(1,0,0)"True/a | cons w tl ⇒ L w a title="logical and" href="cic:/fakeuri.def(1)"∧/a conjunct ? tl L ]. 
 
-definition empty_lang ≝ λS.λw:a href="cic:/matita/tutorial/re/word.def(3)"word/a S.a href="cic:/matita/basics/logic/False.ind(1,0,0)"False/a.
-notation "{}" non associative with precedence 90 for @{'empty_lang}.
-interpretation "empty lang" 'empty_lang = (empty_lang ?).
+definition empty_lang ≝ λS.λw:a href="cic:/matita/tutorial/chapter4/word.def(3)"word/a S.a href="cic:/matita/basics/logic/False.ind(1,0,0)"False/a.  
+(* notation "{}" non associative with precedence 90 for @{'empty_lang}. *)
+interpretation "empty lang" 'empty = (empty_lang ?).
 
-definition sing_lang ≝ λS.λx,w:a href="cic:/matita/tutorial/re/word.def(3)"word/a S.xa title="leibnitz's equality" href="cic:/fakeuri.def(1)"=/aw.
-notation "{x}" non associative with precedence 90 for @{'sing_lang $x}.
+definition sing_lang ≝ λS.λx,w:a href="cic:/matita/tutorial/chapter4/word.def(3)"word/a S.x a title="leibnitz's equality" href="cic:/fakeuri.def(1)"=/a w.
+notation "{: x }" non associative with precedence 90 for @{'sing_lang $x}.
 interpretation "sing lang" 'sing_lang x = (sing_lang ? x).
 
-definition union : ∀S,l1,l2,w.Prop ≝ λS.λl1,l2.λw:a href="cic:/matita/tutorial/re/word.def(3)"word/a S.l1 w a title="logical or" href="cic:/fakeuri.def(1)"∨/a l2 w.
+definition union : ∀S,L1,L2,w.Prop ≝ λS,L1,L2.λw: a href="cic:/matita/tutorial/chapter4/word.def(3)"word/a S.L1 w a title="logical or" href="cic:/fakeuri.def(1)"∨/a L2 w.
 interpretation "union lang" 'union a b = (union ? a b).
 
 definition cat : ∀S,l1,l2,w.Prop ≝ 
-  λS.λl1,l2.λw:a href="cic:/matita/tutorial/re/word.def(3)"word/a S.a title="exists" href="cic:/fakeuri.def(1)"∃/aw1,w2.w1 a title="append" href="cic:/fakeuri.def(1)"@/a w2 a title="leibnitz's equality" href="cic:/fakeuri.def(1)"=/a w a title="logical and" href="cic:/fakeuri.def(1)"∧/a l1 w1 a title="logical and" href="cic:/fakeuri.def(1)"∧/a l2 w2.
-interpretation "cat lang" 'pc a b = (cat ? a b).
+  λS.λl1,l2.λw:a href="cic:/matita/tutorial/chapter4/word.def(3)"word/a S.a title="exists" href="cic:/fakeuri.def(1)"∃/aw1,w2.w1 a title="append" href="cic:/fakeuri.def(1)"@/a w2 a title="leibnitz's equality" href="cic:/fakeuri.def(1)"=/a w a title="logical and" href="cic:/fakeuri.def(1)"∧/a l1 w1 a title="logical and" href="cic:/fakeuri.def(1)"∧/a l2 w2.
+interpretation "cat lang" 'concat a b = (cat ? a b).
 
-definition star ≝ λS.λl.λw:a href="cic:/matita/tutorial/re/word.def(3)"word/a S.a title="exists" href="cic:/fakeuri.def(1)"∃/alw.a href="cic:/matita/tutorial/re/flatten.fix(0,1,4)"flatten/a ? lw a title="leibnitz's equality" href="cic:/fakeuri.def(1)"=/a w a title="logical and" href="cic:/fakeuri.def(1)"∧/a a href="cic:/matita/tutorial/re/conjunct.fix(0,1,4)"conjunct/a ? lw l. 
-interpretation "star lang" 'pk l = (star ? l).
+definition star_lang ≝ λS.λl.λw:a href="cic:/matita/tutorial/chapter4/word.def(3)"word/a S.a title="exists" href="cic:/fakeuri.def(1)"∃/alw. a href="cic:/matita/tutorial/chapter4/flatten.fix(0,1,4)"flatten/a ? lw a title="leibnitz's equality" href="cic:/fakeuri.def(1)"=/a w a title="logical and" href="cic:/fakeuri.def(1)"∧/a a href="cic:/matita/tutorial/chapter4/conjunct.fix(0,1,4)"conjunct/a ? lw l. 
+interpretation "star lang" 'kstar l = (star_lang ? l).
 
-notation > "𝐋 term 70 E" non associative with precedence 75 for @{in_l ? $E}.
+(* notation "ℓ term 70 E" non associative with precedence 75 for @{in_l ? $E}. *)
 
-let rec in_l (S : Alpha) (r : re S) on r : word S → Prop ≝ 
+let rec in_l (S : a href="cic:/matita/tutorial/chapter4/Alpha.ind(1,0,0)"Alpha/a) (r : a href="cic:/matita/tutorial/chapter4/re.ind(1,0,1)"re/a S) on r : a href="cic:/matita/tutorial/chapter4/word.def(3)"word/a S → Prop ≝ 
 match r with
-[ z ⇒ {}
-| e ⇒ { [ ] }
-| s x ⇒ { [x] }
-| c r1 r2 ⇒ 𝐋 r1 · 𝐋 r2
-| o r1 r2 ⇒  𝐋 r1 ∪ 𝐋 r2
-| k r1 ⇒ (𝐋 r1) ^*].
-
-notation "𝐋 term 70 E" non associative with precedence 75 for @{'in_l $E}.
+ [ zero ⇒ a title="empty lang" href="cic:/fakeuri.def(1)"∅/a 
+ | epsilon ⇒ a title="sing lang" href="cic:/fakeuri.def(1)"{/a: a title="nil" href="cic:/fakeuri.def(1)"[/a] }
+ | char x ⇒ a title="sing lang" href="cic:/fakeuri.def(1)"{/a: xa title="cons" href="cic:/fakeuri.def(1)":/a:a title="nil" href="cic:/fakeuri.def(1)"[/a] }
+ | concat r1 r2 ⇒ in_l ? r1 a title="cat lang" href="cic:/fakeuri.def(1)"·/a in_l ? r2 
+ | or r1 r2 ⇒ in_l ? r1 a title="union lang" href="cic:/fakeuri.def(1)"∪/a in_l ? r2 
+ | star r1 ⇒ (in_l ? r1)a title="star lang" href="cic:/fakeuri.def(1)"^/a* 
+ ].
+
+notation "ℓ term 70 E" non associative with precedence 75 for @{'in_l $E}.
 interpretation "in_l" 'in_l E = (in_l ? E).
 interpretation "in_l mem" 'mem w l = (in_l ? l w).
 
-notation "a || b" left associative with precedence 30 for @{'orb $a $b}.
+notation "a ∨ b" left associative with precedence 30 for @{'orb $a $b}.
 interpretation "orb" 'orb a b = (orb a b).
 
-ndefinition if_then_else ≝ λT:Type[0].λe,t,f.match e return λ_.T with [ true ⇒ t | false ⇒ f].
+(* ndefinition if_then_else ≝ λT:Type[0].λe,t,f.match e return λ_.T with [ true ⇒ t | false ⇒ f].
 notation > "'if' term 19 e 'then' term 19 t 'else' term 19 f" non associative with precedence 19 for @{ 'if_then_else $e $t $f }.
 notation < "'if' \nbsp term 19 e \nbsp 'then' \nbsp term 19 t \nbsp 'else' \nbsp term 90 f \nbsp" non associative with precedence 19 for @{ 'if_then_else $e $t $f }.
-interpretation "if_then_else" 'if_then_else e t f = (if_then_else ? e t f).
-
-ninductive pitem (S: Alpha) : Type[0] ≝
-   pz: pitem S
- | pe: pitem S
- | ps: S → pitem S
- | pp: S → pitem S
- | pc: pitem S → pitem S → pitem S
- | po: pitem S → pitem S → pitem S
- | pk: pitem S → pitem S.
+interpretation "if_then_else" 'if_then_else e t f = (if_then_else ? e t f). *)
+
+inductive pitem (S: a href="cic:/matita/tutorial/chapter4/Alpha.ind(1,0,0)"Alpha/a) : Type[0] ≝
+ | pzero: pitem S
+ | pepsilon: pitem S
+ | pchar: S → pitem S
+ | ppoint: S → pitem S
+ | pconcat: pitem S → pitem S → pitem S
+ | por: pitem S → pitem S → pitem S
+ | pstar: pitem S → pitem S.
  
-ndefinition pre ≝ λS.pitem S × bool.
-
-interpretation "pstar" 'pk a = (pk ? a).
-interpretation "por" 'plus a b = (po ? a b).
-interpretation "pcat" 'pc a b = (pc ? a b).
-notation < ".a" non associative with precedence 90 for @{ 'pp $a}.
-notation > "`. term 90 a" non associative with precedence 90 for @{ 'pp $a}.
-interpretation "ppatom" 'pp a = (pp ? a).
-(* to get rid of \middot *)
-ncoercion pc : ∀S.∀p:pitem S. pitem S → pitem S  ≝ pc on _p : pitem ? to ∀_:?.?.
-interpretation "patom" 'ps a = (ps ? a).
-interpretation "pepsilon" 'epsilon = (pe ?).
-interpretation "pempty" 'empty = (pz ?).
-
-notation > "|term 19 e|" non associative with precedence 70 for @{forget ? $e}.
-nlet rec forget (S: Alpha) (l : pitem S) on l: re S ≝
+definition pre ≝ λS.a href="cic:/matita/tutorial/chapter4/pitem.ind(1,0,1)"pitem/a S a title="Product" href="cic:/fakeuri.def(1)"×/a a href="cic:/matita/basics/bool/bool.ind(1,0,0)" title="null"bool/a.
+
+interpretation "pstar" 'kstar a = (pstar ? a).
+interpretation "por" 'plus a b = (por ? a b).
+interpretation "pcat" 'concat a b = (pconcat ? a b).
+
+notation "• a" non associative with precedence 90 for @{ 'ppoint $a}.
+(* notation > "`. term 90 a" non associative with precedence 90 for @{ 'pp $a}. *)
+
+interpretation "ppatom" 'ppoint a = (ppoint ? a).
+(* to get rid of \middot 
+ncoercion pc : ∀S.∀p:pitem S. pitem S → pitem S  ≝ pc on _p : pitem ? to ∀_:?.?. *)
+interpretation "patom" 'pchar a = (pchar ? a).
+interpretation "pepsilon" 'epsilon = (pepsilon ?).
+interpretation "pempty" 'empty = (pzero ?).
+
+notation "\boxv term 19 e \boxv" (* slash boxv *) non associative with precedence 70 for @{forget ? $e}.
+
+let rec forget (S: a href="cic:/matita/tutorial/chapter4/Alpha.ind(1,0,0)"Alpha/a) (l : a href="cic:/matita/tutorial/chapter4/pitem.ind(1,0,1)"pitem/a S) on l: a href="cic:/matita/tutorial/chapter4/re.ind(1,0,1)"re/a S ≝
  match l with
-  [ pz ⇒ ∅
-  | pe ⇒ ϵ
-  | ps x ⇒ `x
-  | pp x ⇒ `x
-  | pc E1 E2 ⇒ (|E1| · |E2|)
-  | po E1 E2 ⇒ (|E1| + |E2|)
-  | pk E ⇒ |E|^* ].
-notation < "|term 19 e|" non associative with precedence 70 for @{'forget $e}.
+  [ pzero ⇒ a title="empty" href="cic:/fakeuri.def(1)"∅/a
+  | pepsilon ⇒ a title="epsilon" href="cic:/fakeuri.def(1)"ϵ/a
+  | pchar x ⇒ a href="cic:/matita/tutorial/chapter4/re.con(0,3,1)"char/a ? x 
+  | ppoint x ⇒ a href="cic:/matita/tutorial/chapter4/re.con(0,3,1)"char/a ? x  
+  | pconcat e1 e2 ⇒ │e1│ a title="cat" href="cic:/fakeuri.def(1)"·/a │e2│
+  | por e1 e2 ⇒ │e1│  a title="or" href="cic:/fakeuri.def(1)"+/a │e2│
+  | pstar e ⇒ │e│a title="star" href="cic:/fakeuri.def(1)"^/a*
+  ].
+
+notation "│ term 19 e │" non associative with precedence 70 for @{'forget $e}.
 interpretation "forget" 'forget a = (forget ? a).
 
-notation "\fst term 90 x" non associative with precedence 90 for @{'fst $x}.
-interpretation "fst" 'fst x = (fst ? ? x).
-notation > "\snd term 90 x" non associative with precedence 90 for @{'snd $x}.
+notation "\fst term 90 x" non associative with precedence 90 for @{'fst $x}.  
+interpretation "fst" 'fst x = (fst ? ? x).  
+notation "\snd term 90 x" non associative with precedence 90 for @{'snd $x}.
 interpretation "snd" 'snd x = (snd ? ? x).
 
-notation > "𝐋\p\ term 70 E" non associative with precedence 75 for @{in_pl ? $E}.
-nlet rec in_pl (S : Alpha) (r : pitem S) on r : word S → Prop ≝ 
+notation "ℓ term 70 E" non associative with precedence 75 for @{in_pl ? $E}.
+
+let rec in_pl (S : a href="cic:/matita/tutorial/chapter4/Alpha.ind(1,0,0)"Alpha/a) (r : a href="cic:/matita/tutorial/chapter4/pitem.ind(1,0,1)"pitem/a S) on r : a href="cic:/matita/tutorial/chapter4/word.def(3)"word/a S → Prop ≝ 
 match r with
-[ pz ⇒ {}
-| pe ⇒ {}
-| ps _ ⇒ {}
-| pp x ⇒ { [x] }
-| pc r1 r2 ⇒ 𝐋\p\ r1 · 𝐋  |r2| ∪ 𝐋\p\ r2
-| po r1 r2 ⇒ 𝐋\p\ r1 ∪ 𝐋\p\ r2
-| pk r1 ⇒ 𝐋\p\ r1 · 𝐋 (|r1|^* ) ].
-notation > "𝐋\p term 70 E" non associative with precedence 75 for @{'in_pl $E}.
-notation "𝐋\sub(\p) term 70 E" non associative with precedence 75 for @{'in_pl $E}.
-interpretation "in_pl" 'in_pl E = (in_pl ? E).
+  [ pzero ⇒ a title="empty lang" href="cic:/fakeuri.def(1)"∅/a 
+  | pepsilon ⇒ a title="empty lang" href="cic:/fakeuri.def(1)"∅/a
+  | pchar _ ⇒ a title="empty lang" href="cic:/fakeuri.def(1)"∅/a
+  | ppoint x ⇒ a title="sing lang" href="cic:/fakeuri.def(1)"{/a: xa title="cons" href="cic:/fakeuri.def(1)":/a:a title="nil" href="cic:/fakeuri.def(1)"[/a] } 
+  | pconcat pe1 pe2 ⇒ in_pl ? pe1 a title="cat lang" href="cic:/fakeuri.def(1)"·/a a title="in_l" href="cic:/fakeuri.def(1)"ℓ/a │pe2│  a title="union lang" href="cic:/fakeuri.def(1)"∪/a in_pl ? pe2 
+  | por pe1 pe2 ⇒ in_pl ? pe1 a title="union lang" href="cic:/fakeuri.def(1)"∪/a in_pl ? pe2
+  | pstar pe ⇒ in_pl ? pe a title="cat lang" href="cic:/fakeuri.def(1)"·/a a title="in_l" href="cic:/fakeuri.def(1)"ℓ/a │pe│a title="star" href="cic:/fakeuri.def(1)"^/a*
+  ].
+
+interpretation "in_pl" 'in_l E = (in_pl ? E).
 interpretation "in_pl mem" 'mem w l = (in_pl ? l w).
 
-ndefinition epsilon ≝ λS,b.if b then { ([ ] : word S) } else {}.
+definition eps: ∀S:a href="cic:/matita/tutorial/chapter4/Alpha.ind(1,0,0)"Alpha/a.a href="cic:/matita/basics/bool/bool.ind(1,0,0)" title="null"bool/a → a href="cic:/matita/tutorial/chapter4/word.def(3)"word/a S → Prop 
+  ≝ λS,b. a href="cic:/matita/basics/bool/if_then_else.def(1)"if_then_else/a ? b a title="sing lang" href="cic:/fakeuri.def(1)"{/a: a title="nil" href="cic:/fakeuri.def(1)"[/a] } a title="empty lang" href="cic:/fakeuri.def(1)"∅/a.
 
-interpretation "epsilon" 'epsilon = (epsilon ?).
-notation < "ϵ b" non associative with precedence 90 for @{'app_epsilon $b}.
-interpretation "epsilon lang" 'app_epsilon b = (epsilon ? b).
+(* interpretation "epsilon" 'epsilon = (epsilon ?). *)
+notation "ϵ _ b" non associative with precedence 90 for @{'app_epsilon $b}.
+interpretation "epsilon lang" 'app_epsilon b = (eps ? b).
 
-ndefinition in_prl ≝ λS : Alpha.λp:pre S.  𝐋\p (\fst p) ∪ ϵ (\snd p).
+definition in_prl ≝ λS : a href="cic:/matita/tutorial/chapter4/Alpha.ind(1,0,0)"Alpha/a.λp:a href="cic:/matita/tutorial/chapter4/pre.def(1)"pre/a S.  a title="in_pl" href="cic:/fakeuri.def(1)"ℓ/a (a title="fst" href="cic:/fakeuri.def(1)"\fst/a p) a title="union lang" href="cic:/fakeuri.def(1)"∪/a a title="epsilon lang" href="cic:/fakeuri.def(1)"ϵ/a_(a title="snd" href="cic:/fakeuri.def(1)"\snd/a p).
   
 interpretation "in_prl mem" 'mem w l = (in_prl ? l w).
-interpretation "in_prl" 'in_pl E = (in_prl ? E).
-
-nlemma append_eq_nil : ∀S.∀w1,w2:word S. w1 @ w2 = [ ] → w1 = [ ].
-#S w1; nelim w1; //. #x tl IH w2; nnormalize; #abs; ndestruct; nqed.
-
-(* lemma 12 *)
-nlemma epsilon_in_true : ∀S.∀e:pre S. [ ] ∈ e ↔ \snd e = true.
-#S r; ncases r; #e b; @; ##[##2: #H; nrewrite > H; @2; /2/; ##] ncases b;//; 
-nnormalize; *; ##[##2:*] nelim e;
-##[ ##1,2: *; ##| #c; *; ##| #c; nnormalize; #; ndestruct; ##| ##7: #p H;
-##| #r1 r2 H G; *; ##[##2: /3/ by or_intror]
-##| #r1 r2 H1 H2; *; /3/ by or_intror, or_introl; ##]
-*; #w1; *; #w2; *; *; #defw1; nrewrite > (append_eq_nil … w1 w2 …); /3/ by {};//;
-nqed.
+interpretation "in_prl" 'in_l E = (in_prl ? E).
+
+lemma not_epsilon_lp :∀S.∀pi:a href="cic:/matita/tutorial/chapter4/pitem.ind(1,0,1)"pitem/a S. a title="logical not" href="cic:/fakeuri.def(1)"¬/a ((a title="in_pl" href="cic:/fakeuri.def(1)"ℓ/a pi) a title="nil" href="cic:/fakeuri.def(1)"[/a]).
+#S #pi (elim pi) normalize /span class="autotactic"2span class="autotrace" trace a href="cic:/matita/basics/logic/Not.con(0,1,1)"nmk/a/span/span/
+  [#pi1 #pi2 #H1 #H2 % * /span class="autotactic"2span class="autotrace" trace a href="cic:/matita/basics/logic/absurd.def(2)"absurd/a/span/span/ * #w1 * #w2 * * #appnil 
+   cases (a href="cic:/matita/tutorial/chapter3/nil_to_nil.def(5)"nil_to_nil/a … appnil) /span class="autotactic"2span class="autotrace" trace a href="cic:/matita/basics/logic/absurd.def(2)"absurd/a/span/span/
+  |#p11 #p12 #H1 #H2 % * /span class="autotactic"2span class="autotrace" trace a href="cic:/matita/basics/logic/absurd.def(2)"absurd/a/span/span/
+  |#pi #H % * #w1 * #w2 * * #appnil (cases (a href="cic:/matita/tutorial/chapter3/nil_to_nil.def(5)"nil_to_nil/a … appnil)) /span class="autotactic"2span class="autotrace" trace a href="cic:/matita/basics/logic/absurd.def(2)"absurd/a/span/span/
+  ]
+qed.
 
-nlemma not_epsilon_lp : ∀S:Alpha.∀e:pitem S. ¬ ((𝐋\p e) [ ]).
-#S e; nelim e; nnormalize; /2/ by nmk;
-##[ #; @; #; ndestruct;
-##| #r1 r2 n1 n2; @; *; /2/; *; #w1; *; #w2; *; *; #H;
-    nrewrite > (append_eq_nil …H…); /2/;
-##| #r1 r2 n1 n2; @; *; /2/;
-##| #r n; @; *; #w1; *; #w2; *; *; #H;     
-    nrewrite > (append_eq_nil …H…); /2/;##]
-nqed.
+lemma if_true_epsilon: ∀S.∀e:a href="cic:/matita/tutorial/chapter4/pre.def(1)"pre/a S. a title="snd" href="cic:/fakeuri.def(1)"\snd/a e a title="leibnitz's equality" href="cic:/fakeuri.def(1)"=/a a href="cic:/matita/basics/bool/bool.con(0,1,0)"true/a → ((a title="in_prl" href="cic:/fakeuri.def(1)"ℓ/a e) a title="nil" href="cic:/fakeuri.def(1)"[/a]).
+#S #e #H %2 >H // qed.
+
+lemma if_epsilon_true : ∀S.∀e:a href="cic:/matita/tutorial/chapter4/pre.def(1)"pre/a S. a title="nil" href="cic:/fakeuri.def(1)"[/a ] a title="in_prl mem" href="cic:/fakeuri.def(1)"∈/a e → a title="snd" href="cic:/fakeuri.def(1)"\snd/a e a title="leibnitz's equality" href="cic:/fakeuri.def(1)"=/a a href="cic:/matita/basics/bool/bool.con(0,1,0)"true/a.
+#S * #pi #b * [normalize #abs @a href="cic:/matita/basics/logic/False_ind.fix(0,1,1)"False_ind/a /2/] cases b normalize // @False_ind
+qed.
+
+definition lor ≝ λS:Alpha.λa,b:pre S.〈\fst a + \fst b,\snd a ∨ \snd b〉.
 
-ndefinition lo ≝ λS:Alpha.λa,b:pre S.〈\fst a + \fst b,\snd a || \snd b〉.
 notation "a ⊕ b" left associative with precedence 60 for @{'oplus $a $b}.
 interpretation "oplus" 'oplus a b = (lo ? a b).