1 (**************************************************************************)
4 (* ||A|| A project by Andrea Asperti *)
6 (* ||I|| Developers: *)
7 (* ||T|| The HELM team. *)
8 (* ||A|| http://helm.cs.unibo.it *)
10 (* \ / This file is distributed under the terms of the *)
11 (* v GNU General Public License Version 2 *)
13 (**************************************************************************)
15 include "logic/equality.ma".
16 include "datatypes/bool.ma".
17 include "higher_order_defs/functions.ma".
18 include "nat/plus.ma".
19 include "nat/orders.ma".
21 inductive list (A:Type) : Type :=
23 | cons: A -> list A -> list A.
25 notation "hvbox(hd break :: tl)"
26 right associative with precedence 46
29 notation "[ list0 x sep ; ]"
30 non associative with precedence 90
31 for ${fold right @'nil rec acc @{'cons $x $acc}}.
33 notation "hvbox(l1 break @ l2)"
34 right associative with precedence 47
35 for @{'append $l1 $l2 }.
37 interpretation "nil" 'nil = (cic:/matita/list/list/list.ind#xpointer(1/1/1) _).
38 interpretation "cons" 'cons hd tl =
39 (cic:/matita/list/list/list.ind#xpointer(1/1/2) _ hd tl).
41 (* theorem test_notation: [O; S O; S (S O)] = O :: S O :: S (S O) :: []. *)
44 \forall A:Type.\forall l:list A.\forall a:A.
52 let rec id_list A (l: list A) on l :=
55 | (cons hd tl) => hd :: id_list A tl ].
57 let rec append A (l1: list A) l2 on l1 :=
60 | (cons hd tl) => hd :: append A tl l2 ].
62 definition tail := \lambda A:Type. \lambda l: list A.
65 | (cons hd tl) => tl].
67 interpretation "append" 'append l1 l2 = (cic:/matita/list/list/append.con _ l1 l2).
69 theorem append_nil: \forall A:Type.\forall l:list A.l @ [] = l.
79 theorem associative_append: \forall A:Type.associative (list A) (append A).
80 intros; unfold; intros;
90 theorem cons_append_commute:
91 \forall A:Type.\forall l1,l2:list A.\forall a:A.
92 a :: (l1 @ l2) = (a :: l1) @ l2.
97 lemma append_cons:\forall A.\forall a:A.\forall l,l1.
100 rewrite > associative_append.
104 inductive permutation (A:Type) : list A -> list A -> Prop \def
105 | refl : \forall l:list A. permutation ? l l
106 | swap : \forall l:list A. \forall x,y:A.
107 permutation ? (x :: y :: l) (y :: x :: l)
108 | trans : \forall l1,l2,l3:list A.
109 permutation ? l1 l2 -> permut1 ? l2 l3 -> permutation ? l1 l3
110 with permut1 : list A -> list A -> Prop \def
111 | step : \forall l1,l2:list A. \forall x,y:A.
112 permut1 ? (l1 @ (x :: y :: l2)) (l1 @ (y :: x :: l2)).
114 include "nat/nat.ma".
116 definition x1 \def S O.
117 definition x2 \def S x1.
118 definition x3 \def S x2.
120 theorem tmp : permutation nat (x1 :: x2 :: x3 :: []) (x1 :: x3 :: x2 :: []).
121 apply (trans ? (x1 :: x2 :: x3 :: []) (x1 :: x2 :: x3 :: []) ?).
123 apply (step ? (x1::[]) [] x2 x3).
128 theorem nil_append_nil_both:
129 \forall A:Type.\forall l1,l2:list A.
130 l1 @ l2 = [] \to l1 = [] \land l2 = [].
134 include "nat/nat.ma".
136 theorem test_notation: [O; S O; S (S O)] = O :: S O :: S (S O) :: [].
140 theorem test_append: [O;O;O;O;O;O] = [O;O;O] @ [O;O] @ [O].
146 let rec nth (A:Type) l d n on n ≝
153 | S n' ⇒ nth A (tail ? l) d n'
156 let rec map (A,B:Type) (f: A → B) (l : list A) on l : list B ≝
157 match l with [ nil ⇒ nil ? | cons x tl ⇒ f x :: (map A B f tl)].
159 let rec foldr (A,B:Type) (f : A → B → B) (b : B) (l : list A) on l : B :=
160 match l with [ nil ⇒ b | (cons a l) ⇒ f a (foldr ? ? f b l)].
162 definition length ≝ λT:Type.λl:list T.foldr T nat (λx,c.S c) O l.
164 definition filter \def
165 \lambda T:Type.\lambda l:list T.\lambda p:T \to bool.
167 (\lambda x,l0.match (p x) with [ true => x::l0 | false => l0]) [] l.
169 definition iota : nat → nat → list nat ≝
170 λn,m. nat_rect (λ_.list ?) (nil ?) (λx,acc.cons ? (n+x) acc) m.
172 (* ### induction principle for functions visiting 2 lists in parallel *)
174 ∀T1,T2:Type.∀l1:list T1.∀l2:list T2.∀P:list T1 → list T2 → Prop.
175 length ? l1 = length ? l2 →
176 (P (nil ?) (nil ?)) →
177 (∀tl1,tl2,hd1,hd2. P tl1 tl2 → P (hd1::tl1) (hd2::tl2)) →
179 intros (T1 T2 l1 l2 P Hl Pnil Pcons);
180 elim l1 in Hl l2 ⊢ % 1 (l2 x1); [ cases l2; intros (Hl); [assumption| simplify in Hl; destruct Hl]]
181 intros 3 (tl1 IH l2); cases l2; [1: simplify; intros 1 (Hl); destruct Hl]
182 intros 1 (Hl); apply Pcons; apply IH; simplify in Hl; destruct Hl; assumption;
185 lemma eq_map : ∀A,B,f,g,l. (∀x.f x = g x) → map A B f l = map A B g l.
186 intros (A B f g l Efg); elim l; simplify; [1: reflexivity ];
187 rewrite > (Efg a); rewrite > H; reflexivity;
190 lemma le_length_filter : \forall A,l,p.length A (filter A l p) \leq length A l.
193 |simplify;apply (bool_elim ? (p a));intro
194 [simplify;apply le_S_S;assumption
195 |simplify;apply le_S;assumption]]