more work on q

[helm.git] / helm / software / matita / library / list / list.ma

diff --git a/helm/software/matita/library/list/list.ma b/helm/software/matita/library/list/list.ma
index 9ecfd50e3ff41bf5cf89e6604ea2ca4986cf7e48..e4787fe8422fcf55a0888cc9da3b4d237239ff0c 100644 (file)
--- a/helm/software/matita/library/list/list.ma
+++ b/helm/software/matita/library/list/list.ma
@@ -12,16 +12,18 @@
 (*                                                                        *)
 (**************************************************************************)
 
-set "baseuri" "cic:/matita/list/".
 include "logic/equality.ma".
+include "datatypes/bool.ma".
 include "higher_order_defs/functions.ma".
+include "nat/plus.ma".
+include "nat/orders.ma".
 
-inductive list (A:Set) : Set :=
+inductive list (A:Type) : Type :=
   | nil: list A
   | cons: A -> list A -> list A.
 
 notation "hvbox(hd break :: tl)"
-  right associative with precedence 46
+  right associative with precedence 47
   for @{'cons $hd $tl}.
 
 notation "[ list0 x sep ; ]"
@@ -32,15 +34,14 @@ notation "hvbox(l1 break @ l2)"
   right associative with precedence 47
   for @{'append $l1 $l2 }.
 
-interpretation "nil" 'nil = (cic:/matita/list/list.ind#xpointer(1/1/1) _).
+interpretation "nil" 'nil = (cic:/matita/list/list/list.ind#xpointer(1/1/1) _).
 interpretation "cons" 'cons hd tl =
-  (cic:/matita/list/list.ind#xpointer(1/1/2) _ hd tl).
+  (cic:/matita/list/list/list.ind#xpointer(1/1/2) _ hd tl).
 
 (* theorem test_notation: [O; S O; S (S O)] = O :: S O :: S (S O) :: []. *)
 
 theorem nil_cons:
-  \forall A:Set.\forall l:list A.\forall a:A.
-    a::l <> [].
+  \forall A:Type.\forall l:list A.\forall a:A. a::l ≠ [].
   intros;
   unfold Not;
   intros;
@@ -57,14 +58,14 @@ let rec append A (l1: list A) l2 on l1 :=
   [ nil => l2
   | (cons hd tl) => hd :: append A tl l2 ].
 
-definition tail := \lambda A:Set. \lambda l: list A.
+definition tail := \lambda A:Type. \lambda l: list A.
   match l with
   [ nil => []
   | (cons hd tl) => tl].
 
-interpretation "append" 'append l1 l2 = (cic:/matita/list/append.con _ l1 l2).
+interpretation "append" 'append l1 l2 = (cic:/matita/list/list/append.con _ l1 l2).
 
-theorem append_nil: \forall A:Set.\forall l:list A.l @ [] = l.
+theorem append_nil: \forall A:Type.\forall l:list A.l @ [] = l.
   intros;
   elim l;
   [ reflexivity;
@@ -74,7 +75,7 @@ theorem append_nil: \forall A:Set.\forall l:list A.l @ [] = l.
   ]
 qed.
 
-theorem associative_append: \forall A:Set.associative (list A) (append A).
+theorem associative_append: \forall A:Type.associative (list A) (append A).
   intros; unfold; intros;
   elim x;
   [ simplify;
@@ -86,13 +87,20 @@ theorem associative_append: \forall A:Set.associative (list A) (append A).
 qed.
 
 theorem cons_append_commute:
-  \forall A:Set.\forall l1,l2:list A.\forall a:A.
+  \forall A:Type.\forall l1,l2:list A.\forall a:A.
     a :: (l1 @ l2) = (a :: l1) @ l2.
   intros;
   reflexivity;
 qed.
 
-inductive permutation (A:Set) : list A -> list A -> Prop \def
+lemma append_cons:\forall A.\forall a:A.\forall l,l1. 
+l@(a::l1)=(l@[a])@l1.
+intros.
+rewrite > associative_append.
+reflexivity.
+qed.
+
+inductive permutation (A:Type) : list A -> list A -> Prop \def
   | refl : \forall l:list A. permutation ? l l
   | swap : \forall l:list A. \forall x,y:A. 
               permutation ? (x :: y :: l) (y :: x :: l)
@@ -117,7 +125,7 @@ theorem tmp : permutation nat (x1 :: x2 :: x3 :: []) (x1 :: x3 :: x2 :: []).
 
 (*
 theorem nil_append_nil_both:
-  \forall A:Set.\forall l1,l2:list A.
+  \forall A:Type.\forall l1,l2:list A.
     l1 @ l2 = [] \to l1 = [] \land l2 = [].
 *)
 
@@ -133,3 +141,63 @@ simplify.
 reflexivity.
 qed.
 *)
+
+definition nth ≝
+  λA:Type.
+    let rec nth l d n on n ≝
+      match n with
+      [ O ⇒
+         match l with
+         [ nil ⇒ d
+         | cons (x : A) _ ⇒ x
+         ]
+      | S n' ⇒ nth (tail ? l) d n']
+    in nth.
+  
+definition map ≝
+  λA,B:Type.λf:A→B.
+  let rec map (l : list A) on l : list B ≝
+    match l with [ nil ⇒ nil ? | cons x tl ⇒ f x :: (map tl)]
+  in map.
+  
+definition foldr ≝
+  λA,B:Type.λf:A→B→B.λb:B.
+  let rec foldr (l : list A) on l : B := 
+    match l with [ nil ⇒ b | (cons a l) ⇒ f a (foldr l)]
+  in foldr.
+   
+definition length ≝ λT:Type.λl:list T.foldr T nat (λx,c.S c) O l.
+
+definition filter \def 
+  \lambda T:Type.\lambda l:list T.\lambda p:T \to bool.
+  foldr T (list T) 
+    (\lambda x,l0.match (p x) with [ true => x::l0 | false => l0]) [] l.
+
+definition iota : nat → nat → list nat ≝
+  λn,m. nat_rect (λ_.list ?) (nil ?) (λx,acc.cons ? (n+x) acc) m.
+  
+(* ### induction principle for functions visiting 2 lists in parallel *)
+lemma list_ind2 : 
+  ∀T1,T2:Type.∀l1:list T1.∀l2:list T2.∀P:list T1 → list T2 → Prop.
+  length ? l1 = length ? l2 →
+  (P (nil ?) (nil ?)) → 
+  (∀tl1,tl2,hd1,hd2. P tl1 tl2 → P (hd1::tl1) (hd2::tl2)) → 
+  P l1 l2.
+intros (T1 T2 l1 l2 P Hl Pnil Pcons);
+elim l1 in Hl l2 ⊢ % 1 (l2 x1); [ cases l2; intros (Hl); [assumption| simplify in Hl; destruct Hl]]
+intros 3 (tl1 IH l2); cases l2; [1: simplify; intros 1 (Hl); destruct Hl] 
+intros 1 (Hl); apply Pcons; apply IH; simplify in Hl; destruct Hl; assumption;
+qed.
+
+lemma eq_map : ∀A,B,f,g,l. (∀x.f x = g x) → map A B f l = map A B g l.
+intros (A B f g l Efg); elim l; simplify; [1: reflexivity ];
+rewrite > (Efg a); rewrite > H; reflexivity;  
+qed.
+
+lemma le_length_filter : \forall A,l,p.length A (filter A l p) \leq length A l.
+intros;elim l
+  [simplify;apply le_n
+  |simplify;apply (bool_elim ? (p a));intro
+     [simplify;apply le_S_S;assumption
+     |simplify;apply le_S;assumption]]
+qed.