]> matita.cs.unibo.it Git - helm.git/blob - helm/software/matita/library/nat/factorization.ma
Dummy dependent products in inductive types arities are no longer cleaned.
[helm.git] / helm / software / matita / library / nat / factorization.ma
1 (**************************************************************************)
2 (*       ___                                                                *)
3 (*      ||M||                                                             *)
4 (*      ||A||       A project by Andrea Asperti                           *)
5 (*      ||T||                                                             *)
6 (*      ||I||       Developers:                                           *)
7 (*      ||T||       A.Asperti, C.Sacerdoti Coen,                          *)
8 (*      ||A||       E.Tassi, S.Zacchiroli                                 *)
9 (*      \   /                                                             *)
10 (*       \ /        Matita is distributed under the terms of the          *)
11 (*        v         GNU Lesser General Public License Version 2.1         *)
12 (*                                                                        *)
13 (**************************************************************************)
14
15 include "nat/ord.ma".
16
17 (* the following factorization algorithm looks for the largest prime
18    factor. *)
19 definition max_prime_factor \def \lambda n:nat.
20 (max n (\lambda p:nat.eqb (n \mod (nth_prime p)) O)).
21
22 theorem lt_SO_max_prime: \forall m. S O <  m \to 
23 S O < max m (λi:nat.primeb i∧divides_b i m).
24 intros.
25 apply (lt_to_le_to_lt ? (smallest_factor m))
26   [apply lt_SO_smallest_factor.assumption
27   |apply f_m_to_le_max
28     [apply le_smallest_factor_n
29     |apply true_to_true_to_andb_true
30       [apply prime_to_primeb_true.
31        apply prime_smallest_factor_n.
32        assumption
33       |apply divides_to_divides_b_true
34         [apply lt_O_smallest_factor.apply lt_to_le.assumption
35         |apply divides_smallest_factor_n.
36          apply lt_to_le.assumption
37         ]
38       ]
39     ]
40   ]
41 qed.
42 (* max_prime_factor is indeed a factor *)
43 theorem divides_max_prime_factor_n:
44   \forall n:nat. (S O) < n
45   \to nth_prime (max_prime_factor n) \divides n.
46 intros.
47 apply divides_b_true_to_divides.
48 apply (f_max_true  (\lambda p:nat.eqb (n \mod (nth_prime p)) O) n);
49 cut (\exists i. nth_prime i = smallest_factor n);
50   [ elim Hcut.
51     apply (ex_intro nat ? a);
52     split;
53     [ apply (trans_le a (nth_prime a));
54       [ apply le_n_fn;
55         exact lt_nth_prime_n_nth_prime_Sn;
56       | rewrite > H1;
57         apply le_smallest_factor_n; ]
58     | rewrite > H1;
59       change with (divides_b (smallest_factor n) n = true);
60       apply divides_to_divides_b_true;
61       [ apply (trans_lt ? (S O));
62         [ unfold lt; apply le_n;
63         | apply lt_SO_smallest_factor; assumption; ]
64       | letin x \def le.autobatch new.
65          (*       
66        apply divides_smallest_factor_n;
67         apply (trans_lt ? (S O));
68         [ unfold lt; apply le_n;
69         | assumption; ] *) ] ]
70   | autobatch. 
71     (* 
72     apply prime_to_nth_prime;
73     apply prime_smallest_factor_n;
74     assumption; *) ] 
75 qed.
76
77 theorem divides_to_max_prime_factor : \forall n,m. (S O) < n \to O < m \to n \divides m \to 
78 max_prime_factor n \le max_prime_factor m.
79 intros.unfold max_prime_factor.
80 apply f_m_to_le_max.
81 apply (trans_le ? n).
82 apply le_max_n.apply divides_to_le.assumption.assumption.
83 change with (divides_b (nth_prime (max_prime_factor n)) m = true).
84 apply divides_to_divides_b_true.
85 cut (prime (nth_prime (max_prime_factor n))).
86 apply lt_O_nth_prime_n.apply prime_nth_prime.
87 cut (nth_prime (max_prime_factor n) \divides n).
88 autobatch.
89 autobatch.
90 (*
91   [ apply (transitive_divides ? n);
92     [ apply divides_max_prime_factor_n.
93       assumption.
94     | assumption. 
95     ]
96   | apply divides_b_true_to_divides;
97     [ apply lt_O_nth_prime_n.
98     | apply divides_to_divides_b_true;
99       [ apply lt_O_nth_prime_n.
100       | apply divides_max_prime_factor_n.
101         assumption.
102       ]
103     ]
104   ]
105 *)  
106 qed.
107
108 theorem divides_to_max_prime_factor1 : \forall n,m. O < n \to O < m \to n \divides m \to 
109 max_prime_factor n \le max_prime_factor m.
110 intros 3.
111 elim (le_to_or_lt_eq ? ? H)
112   [apply divides_to_max_prime_factor
113     [assumption|assumption|assumption]
114   |rewrite < H1.
115    simplify.apply le_O_n.
116   ]
117 qed.
118
119 theorem max_prime_factor_to_not_p_ord_O : \forall n,p,r.
120   (S O) < n \to
121   p = max_prime_factor n \to
122   p_ord n (nth_prime p) \neq pair nat nat O r.
123 intros.unfold Not.intro.
124 apply (p_ord_O_to_not_divides ? ? ? ? H2)
125   [apply (trans_lt ? (S O))[apply lt_O_S|assumption]
126   |rewrite > H1.
127    apply divides_max_prime_factor_n.
128    assumption
129   ]
130 qed.
131
132 theorem p_ord_to_lt_max_prime_factor: \forall n,p,q,r. O < n \to
133 p = max_prime_factor n \to 
134 (pair nat nat q r) = p_ord n (nth_prime p) \to
135 (S O) < r \to max_prime_factor r < p.
136 intros.
137 rewrite > H1.
138 cut (max_prime_factor r \lt max_prime_factor n \lor
139     max_prime_factor r = max_prime_factor n).
140 elim Hcut.assumption.
141 absurd (nth_prime (max_prime_factor n) \divides r).
142 rewrite < H4.
143 apply divides_max_prime_factor_n.
144 assumption.unfold Not.
145 intro.
146 cut (r \mod (nth_prime (max_prime_factor n)) \neq O);
147   [unfold Not in Hcut1.autobatch new.
148     (*
149     apply Hcut1.apply divides_to_mod_O;
150     [ apply lt_O_nth_prime_n.
151     | assumption.
152     ]
153     *)
154   |letin z \def le.
155    cut(pair nat nat q r=p_ord_aux n n (nth_prime (max_prime_factor n)));
156    [2: rewrite < H1.assumption.|letin x \def le.autobatch width = 4 depth = 2]
157    (* CERCA COME MAI le_n non lo applica se lo trova come Const e non Rel *)
158   ].
159 (*
160     apply (p_ord_aux_to_not_mod_O n n ? q r);
161     [ apply lt_SO_nth_prime_n.
162     | assumption.
163     | apply le_n.
164     | rewrite < H1.assumption.
165     ]
166   ].
167 *)  
168 apply (le_to_or_lt_eq (max_prime_factor r)  (max_prime_factor n)).
169 apply divides_to_max_prime_factor.
170 assumption.assumption.
171 apply (witness r n ((nth_prime p) \sup q)).
172 rewrite < sym_times.
173 apply (p_ord_aux_to_exp n n ? q r).
174 apply lt_O_nth_prime_n.assumption.
175 qed.
176
177 theorem p_ord_to_lt_max_prime_factor1: \forall n,p,q,r. O < n \to
178 max_prime_factor n \le p \to 
179 (pair nat nat q r) = p_ord n (nth_prime p) \to
180 (S O) < r \to max_prime_factor r < p.
181 intros.
182 cut (max_prime_factor n < p \lor max_prime_factor n = p).
183 elim Hcut.apply (le_to_lt_to_lt ? (max_prime_factor n)).
184 apply divides_to_max_prime_factor.assumption.assumption.
185 apply (witness r n ((nth_prime p) \sup q)).
186 rewrite > sym_times.
187 apply (p_ord_aux_to_exp n n).
188 apply lt_O_nth_prime_n.
189 assumption.assumption.
190 apply (p_ord_to_lt_max_prime_factor n ? q).
191 assumption.apply sym_eq.assumption.assumption.assumption.
192 apply (le_to_or_lt_eq ? p H1).
193 qed.
194
195 lemma lt_max_prime_factor_to_not_divides: \forall n,p:nat.
196 O < n \to n=S O \lor max_prime_factor n < p \to 
197 (nth_prime p \ndivides n).
198 intros.unfold Not.intro.
199 elim H1
200   [rewrite > H3 in H2.
201    apply (le_to_not_lt (nth_prime p) (S O))
202     [apply divides_to_le[apply le_n|assumption]
203     |apply lt_SO_nth_prime_n
204     ]
205   |apply (not_le_Sn_n p).
206    change with (p < p).
207    apply (le_to_lt_to_lt ? ? ? ? H3).
208    unfold max_prime_factor.
209    apply  f_m_to_le_max
210     [apply (trans_le ? (nth_prime p))
211       [apply lt_to_le.
212        apply lt_n_nth_prime_n
213       |apply divides_to_le;assumption
214       ]
215     |apply eq_to_eqb_true.
216      apply divides_to_mod_O
217       [apply lt_O_nth_prime_n|assumption]
218     ]
219   ]
220 qed.
221
222 (* datatypes and functions *)
223
224 inductive nat_fact : Set \def
225     nf_last : nat \to nat_fact   
226   | nf_cons : nat \to nat_fact \to nat_fact.
227
228 inductive nat_fact_all : Set \def
229     nfa_zero : nat_fact_all
230   | nfa_one : nat_fact_all
231   | nfa_proper : nat_fact \to nat_fact_all.
232
233 let rec factorize_aux p n acc \def
234   match p with 
235   [ O \Rightarrow acc
236   | (S p1) \Rightarrow 
237     match p_ord n (nth_prime p1) with
238     [ (pair q r) \Rightarrow 
239       factorize_aux p1 r (nf_cons q acc)]].
240   
241 definition factorize : nat \to nat_fact_all \def \lambda n:nat.
242   match n with
243     [ O \Rightarrow nfa_zero
244     | (S n1) \Rightarrow
245       match n1 with
246       [ O \Rightarrow nfa_one
247     | (S n2) \Rightarrow 
248       let p \def (max (S(S n2)) (\lambda p:nat.eqb ((S(S n2)) \mod (nth_prime p)) O)) in
249       match p_ord (S(S n2)) (nth_prime p) with
250       [ (pair q r) \Rightarrow 
251            nfa_proper (factorize_aux p r (nf_last (pred q)))]]].
252            
253 let rec defactorize_aux f i \def
254   match f with
255   [ (nf_last n) \Rightarrow (nth_prime i) \sup (S n)
256   | (nf_cons n g) \Rightarrow 
257       (nth_prime i) \sup n *(defactorize_aux g (S i))].
258       
259 definition defactorize : nat_fact_all \to nat \def
260 \lambda f : nat_fact_all. 
261 match f with 
262 [ nfa_zero \Rightarrow O
263 | nfa_one \Rightarrow (S O)
264 | (nfa_proper g) \Rightarrow defactorize_aux g O]. 
265
266 theorem lt_O_defactorize_aux:
267  \forall f:nat_fact.
268  \forall i:nat.
269  O < defactorize_aux f i.
270 intro; elim f;
271 [1,2:
272   simplify; unfold lt;
273   rewrite > times_n_SO;
274   apply le_times;
275   [ change with (O < nth_prime i);
276     apply lt_O_nth_prime_n;
277   |2,3:
278     change with (O < exp (nth_prime i) n);
279     apply lt_O_exp;
280     apply lt_O_nth_prime_n;
281   | change with (O < defactorize_aux n1 (S i));
282     apply H; ] ]
283 qed.
284
285 theorem lt_SO_defactorize_aux: \forall f:nat_fact.\forall i:nat.
286 S O < defactorize_aux f i.
287 intro.elim f.simplify.unfold lt.
288 rewrite > times_n_SO.
289 apply le_times.
290 change with (S O < nth_prime i).
291 apply lt_SO_nth_prime_n.
292 change with (O < exp (nth_prime i) n).
293 apply lt_O_exp.
294 apply lt_O_nth_prime_n.
295 simplify.unfold lt.
296 rewrite > times_n_SO.
297 rewrite > sym_times.
298 apply le_times.
299 change with (O < exp (nth_prime i) n).
300 apply lt_O_exp.
301 apply lt_O_nth_prime_n.
302 change with (S O < defactorize_aux n1 (S i)).
303 apply H.
304 qed.
305
306 theorem defactorize_aux_factorize_aux : 
307 \forall p,n:nat.\forall acc:nat_fact.O < n \to
308 ((n=(S O) \land p=O) \lor max_prime_factor n < p) \to
309 defactorize_aux (factorize_aux p n acc) O = n*(defactorize_aux acc p).
310 intro.elim p.simplify.
311 elim H1.elim H2.rewrite > H3.
312 rewrite > sym_times. apply times_n_SO.
313 apply False_ind.apply (not_le_Sn_O (max_prime_factor n) H2).
314 simplify.
315 (* generalizing the goal: I guess there exists a better way *)
316 cut (\forall q,r.(pair nat nat q r) = (p_ord_aux n1 n1 (nth_prime n)) \to
317 defactorize_aux match (p_ord_aux n1 n1 (nth_prime n)) with
318 [(pair q r)  \Rightarrow (factorize_aux n r (nf_cons q acc))] O =
319 n1*defactorize_aux acc (S n)).
320 apply (Hcut (fst ? ? (p_ord_aux n1 n1 (nth_prime n)))
321 (snd ? ? (p_ord_aux n1 n1 (nth_prime n)))).
322 apply sym_eq.apply eq_pair_fst_snd.
323 intros.
324 rewrite < H3.
325 simplify.
326 cut (n1 = r * (nth_prime n) \sup q).
327 rewrite > H.
328 simplify.rewrite < assoc_times.
329 rewrite < Hcut.reflexivity.
330 cut (O < r \lor O = r).
331 elim Hcut1.assumption.absurd (n1 = O).
332 rewrite > Hcut.rewrite < H4.reflexivity.
333 unfold Not. intro.apply (not_le_Sn_O O).
334 rewrite < H5 in \vdash (? ? %).assumption.
335 apply le_to_or_lt_eq.apply le_O_n.
336 cut ((S O) < r \lor (S O) \nlt r).
337 elim Hcut1.
338 right.
339 apply (p_ord_to_lt_max_prime_factor1 n1 ? q r).
340 assumption.elim H2.
341 elim H5.
342 apply False_ind.
343 apply (not_eq_O_S n).apply sym_eq.assumption.
344 apply le_S_S_to_le.
345 exact H5.
346 assumption.assumption.
347 cut (r=(S O)).
348 apply (nat_case n).
349 left.split.assumption.reflexivity.
350 intro.right.rewrite > Hcut2.
351 simplify.unfold lt.apply le_S_S.apply le_O_n.
352 cut (r < (S O) ∨ r=(S O)).
353 elim Hcut2.absurd (O=r).
354 apply le_n_O_to_eq.apply le_S_S_to_le.exact H5.
355 unfold Not.intro.
356 cut (O=n1).
357 apply (not_le_Sn_O O).
358 rewrite > Hcut3 in ⊢ (? ? %).
359 assumption.rewrite > Hcut. 
360 rewrite < H6.reflexivity.
361 assumption.
362 apply (le_to_or_lt_eq r (S O)).
363 apply not_lt_to_le.assumption.
364 apply (decidable_lt (S O) r).
365 rewrite > sym_times.
366 apply (p_ord_aux_to_exp n1 n1).
367 apply lt_O_nth_prime_n.assumption.
368 qed.
369
370 theorem defactorize_factorize: \forall n:nat.defactorize (factorize n) = n.
371 intro.
372 apply (nat_case n).reflexivity.
373 intro.apply (nat_case m).reflexivity.
374 intro.
375 change with  
376 (let p \def (max (S(S m1)) (\lambda p:nat.eqb ((S(S m1)) \mod (nth_prime p)) O)) in
377 defactorize (match p_ord (S(S m1)) (nth_prime p) with
378 [ (pair q r) \Rightarrow 
379    nfa_proper (factorize_aux p r (nf_last (pred q)))])=(S(S m1))).
380 intro.
381 (* generalizing the goal; find a better way *)
382 cut (\forall q,r.(pair nat nat q r) = (p_ord (S(S m1)) (nth_prime p)) \to
383 defactorize (match p_ord (S(S m1)) (nth_prime p) with
384 [ (pair q r) \Rightarrow 
385    nfa_proper (factorize_aux p r (nf_last (pred q)))])=(S(S m1))).
386 apply (Hcut (fst ? ? (p_ord (S(S m1)) (nth_prime p)))
387 (snd ? ? (p_ord (S(S m1)) (nth_prime p)))).
388 apply sym_eq.apply eq_pair_fst_snd.
389 intros.
390 rewrite < H.
391 simplify.
392 cut ((S(S m1)) = (nth_prime p) \sup q *r).
393 cut (O<r).
394 rewrite > defactorize_aux_factorize_aux.
395 change with (r*(nth_prime p) \sup (S (pred q)) = (S(S m1))).
396 cut ((S (pred q)) = q).
397 rewrite > Hcut2.
398 rewrite > sym_times.
399 apply sym_eq.
400 apply (p_ord_aux_to_exp (S(S m1))).
401 apply lt_O_nth_prime_n.
402 assumption.
403 (* O < q *)
404 apply sym_eq. apply S_pred.
405 cut (O < q \lor O = q).
406 elim Hcut2.assumption.
407 absurd (nth_prime p \divides S (S m1)).
408 apply (divides_max_prime_factor_n (S (S m1))).
409 unfold lt.apply le_S_S.apply le_S_S. apply le_O_n.
410 cut ((S(S m1)) = r).
411 rewrite > Hcut3 in \vdash (? (? ? %)).
412 change with (nth_prime p \divides r \to False).
413 intro.
414 apply (p_ord_aux_to_not_mod_O (S(S m1)) (S(S m1)) (nth_prime p) q r).
415 apply lt_SO_nth_prime_n.
416 unfold lt.apply le_S_S.apply le_O_n.apply le_n.
417 assumption.
418 apply divides_to_mod_O.apply lt_O_nth_prime_n.assumption.
419 rewrite > times_n_SO in \vdash (? ? ? %).
420 rewrite < sym_times.
421 rewrite > (exp_n_O (nth_prime p)).
422 rewrite > H1 in \vdash (? ? ? (? (? ? %) ?)).
423 assumption.
424 apply le_to_or_lt_eq.apply le_O_n.assumption.
425 (* e adesso l'ultimo goal. TASSI: che ora non e' piu' l'ultimo :P *)
426 cut ((S O) < r \lor S O \nlt r).
427 elim Hcut2.
428 right. 
429 apply (p_ord_to_lt_max_prime_factor1 (S(S m1)) ? q r).
430 unfold lt.apply le_S_S. apply le_O_n.
431 apply le_n.
432 assumption.assumption.
433 cut (r=(S O)).
434 apply (nat_case p).
435 left.split.assumption.reflexivity.
436 intro.right.rewrite > Hcut3.
437 simplify.unfold lt.apply le_S_S.apply le_O_n.
438 cut (r \lt (S O) \or r=(S O)).
439 elim Hcut3.absurd (O=r).
440 apply le_n_O_to_eq.apply le_S_S_to_le.exact H2.
441 unfold Not.intro.
442 apply (not_le_Sn_O O).
443 rewrite > H3 in \vdash (? ? %).assumption.assumption.
444 apply (le_to_or_lt_eq r (S O)).
445 apply not_lt_to_le.assumption.
446 apply (decidable_lt (S O) r).
447 (* O < r *)
448 cut (O < r \lor O = r).
449 elim Hcut1.assumption. 
450 apply False_ind.
451 apply (not_eq_O_S (S m1)).
452 rewrite > Hcut.rewrite < H1.rewrite < times_n_O.reflexivity.
453 apply le_to_or_lt_eq.apply le_O_n.
454 (* prova del cut *)
455 apply (p_ord_aux_to_exp (S(S m1))).
456 apply lt_O_nth_prime_n.
457 assumption.
458 (* fine prova cut *)
459 qed.
460
461 let rec max_p f \def
462 match f with
463 [ (nf_last n) \Rightarrow O
464 | (nf_cons n g) \Rightarrow S (max_p g)].
465
466 let rec max_p_exponent f \def
467 match f with
468 [ (nf_last n) \Rightarrow n
469 | (nf_cons n g) \Rightarrow max_p_exponent g].
470
471 theorem divides_max_p_defactorize: \forall f:nat_fact.\forall i:nat. 
472 nth_prime ((max_p f)+i) \divides defactorize_aux f i.
473 intro.
474 elim f.simplify.apply (witness ? ? ((nth_prime i) \sup n)).
475 reflexivity.
476 change with 
477 (nth_prime (S(max_p n1)+i) \divides
478 (nth_prime i) \sup n *(defactorize_aux n1 (S i))).
479 elim (H (S i)).
480 rewrite > H1.
481 rewrite < sym_times.
482 rewrite > assoc_times.
483 rewrite < plus_n_Sm.
484 apply (witness ? ? (n2* (nth_prime i) \sup n)).
485 reflexivity.
486 qed.
487
488 lemma eq_p_max: \forall n,p,r:nat. O < n \to
489 O < r \to
490 r = (S O) \lor (max r (\lambda p:nat.eqb (r \mod (nth_prime p)) O)) < p \to
491 p = max_prime_factor (r*(nth_prime p)\sup n).
492 intros.
493 apply sym_eq.
494 unfold max_prime_factor.
495 apply max_spec_to_max.
496 split
497   [split
498     [rewrite > times_n_SO in \vdash (? % ?).
499      rewrite > sym_times.
500      apply le_times
501       [assumption
502       |apply lt_to_le.
503        apply (lt_to_le_to_lt ? (nth_prime p))
504         [apply lt_n_nth_prime_n
505         |rewrite > exp_n_SO in \vdash (? % ?).
506          apply le_exp
507           [apply lt_O_nth_prime_n
508           |assumption
509           ]
510         ]
511       ]
512     |apply eq_to_eqb_true.
513      apply divides_to_mod_O
514       [apply lt_O_nth_prime_n
515       |apply (lt_O_n_elim ? H).
516        intro.
517        apply (witness ? ? (r*(nth_prime p \sup m))).
518        rewrite < assoc_times.
519        rewrite < sym_times in \vdash (? ? ? (? % ?)).
520        rewrite > exp_n_SO in \vdash (? ? ? (? (? ? %) ?)).
521        rewrite > assoc_times.
522        rewrite < exp_plus_times.
523        reflexivity
524       ]
525     ]
526   |intros.  
527    apply not_eq_to_eqb_false.
528    unfold Not.intro.
529    lapply (mod_O_to_divides ? ? ? H5)
530     [apply lt_O_nth_prime_n
531     |cut (Not (divides (nth_prime i) ((nth_prime p)\sup n)))
532       [elim H2
533         [rewrite > H6 in Hletin.
534          simplify in Hletin.
535          rewrite < plus_n_O in Hletin.
536          apply Hcut.assumption
537         |elim (divides_times_to_divides ? ? ? ? Hletin)
538           [apply (lt_to_not_le ? ? H3).
539            apply lt_to_le. 
540            apply (le_to_lt_to_lt ? ? ? ? H6).
541            apply f_m_to_le_max
542             [apply (trans_le ? (nth_prime i))
543               [apply lt_to_le.
544                apply lt_n_nth_prime_n
545               |apply divides_to_le[assumption|assumption]
546               ]
547             |apply eq_to_eqb_true.
548              apply divides_to_mod_O
549               [apply lt_O_nth_prime_n|assumption]
550             ]
551           |apply prime_nth_prime
552           |apply Hcut.assumption
553           ]
554         ]
555       |unfold Not.intro.
556        apply (lt_to_not_eq ? ? H3).
557        apply sym_eq.
558        elim (prime_nth_prime p).
559        apply injective_nth_prime.
560        apply H8
561         [apply (divides_exp_to_divides ? ? ? ? H6).
562          apply prime_nth_prime.
563         |apply lt_SO_nth_prime_n
564         ]
565       ]
566     ]
567   ]
568 qed.
569
570 theorem  not_divides_defactorize_aux: \forall f:nat_fact. \forall i,j:nat.
571 i < j \to nth_prime i \ndivides defactorize_aux f j.
572 intro.elim f.
573 change with
574 (nth_prime i \divides (nth_prime j) \sup (S n) \to False).
575 intro.absurd ((nth_prime i) = (nth_prime j)).
576 apply (divides_exp_to_eq ? ? (S n)).
577 apply prime_nth_prime.apply prime_nth_prime.
578 assumption.unfold Not.
579 intro.cut (i = j).
580 apply (not_le_Sn_n i).rewrite > Hcut in \vdash (? ? %).assumption.
581 apply (injective_nth_prime ? ? H2).
582 unfold Not.simplify.
583 intro.
584 cut (nth_prime i \divides (nth_prime j) \sup n
585 \lor nth_prime i \divides defactorize_aux n1 (S j)).
586 elim Hcut.
587 absurd ((nth_prime i) = (nth_prime j)).
588 apply (divides_exp_to_eq ? ? n).
589 apply prime_nth_prime.apply prime_nth_prime.
590 assumption.unfold Not.
591 intro.
592 cut (i = j).
593 apply (not_le_Sn_n i).rewrite > Hcut1 in \vdash (? ? %).assumption.
594 apply (injective_nth_prime ? ? H4).
595 apply (H i (S j)).
596 apply (trans_lt ? j).assumption.unfold lt.apply le_n.
597 assumption.
598 apply divides_times_to_divides.
599 apply prime_nth_prime.assumption.
600 qed.
601
602 lemma not_eq_nf_last_nf_cons: \forall g:nat_fact.\forall n,m,i:nat.
603 \lnot (defactorize_aux (nf_last n) i= defactorize_aux (nf_cons m g) i).
604 intros.
605 change with 
606 (exp (nth_prime i) (S n) = defactorize_aux (nf_cons m g) i \to False).
607 intro.
608 cut (S(max_p g)+i= i).
609 apply (not_le_Sn_n i).
610 rewrite < Hcut in \vdash (? ? %).
611 simplify.apply le_S_S.
612 apply le_plus_n.
613 apply injective_nth_prime.
614 apply (divides_exp_to_eq ? ? (S n)).
615 apply prime_nth_prime.apply prime_nth_prime.
616 rewrite > H.
617 change with (divides (nth_prime ((max_p (nf_cons m g))+i)) 
618 (defactorize_aux (nf_cons m g) i)).
619 apply divides_max_p_defactorize.
620 qed.
621
622 lemma not_eq_nf_cons_O_nf_cons: \forall f,g:nat_fact.\forall n,i:nat.
623 \lnot (defactorize_aux (nf_cons O f) i= defactorize_aux (nf_cons (S n) g) i).
624 intros.
625 simplify.unfold Not.rewrite < plus_n_O.
626 intro.
627 apply (not_divides_defactorize_aux f i (S i) ?).
628 unfold lt.apply le_n.
629 rewrite > H.
630 rewrite > assoc_times.
631 apply (witness ? ? ((exp (nth_prime i) n)*(defactorize_aux g (S i)))).
632 reflexivity.
633 qed.
634
635 theorem eq_defactorize_aux_to_eq: \forall f,g:nat_fact.\forall i:nat.
636 defactorize_aux f i = defactorize_aux g i \to f = g.
637 intro.
638 elim f.
639 generalize in match H.
640 elim g.
641 apply eq_f.
642 apply inj_S. apply (inj_exp_r (nth_prime i)).
643 apply lt_SO_nth_prime_n.
644 assumption.
645 apply False_ind.
646 apply (not_eq_nf_last_nf_cons n2 n n1 i H2).
647 generalize in match H1.
648 elim g.
649 apply False_ind.
650 apply (not_eq_nf_last_nf_cons n1 n2 n i).
651 apply sym_eq. assumption.
652 simplify in H3.
653 generalize in match H3.
654 apply (nat_elim2 (\lambda n,n2.
655 ((nth_prime i) \sup n)*(defactorize_aux n1 (S i)) =
656 ((nth_prime i) \sup n2)*(defactorize_aux n3 (S i)) \to
657 nf_cons n n1 = nf_cons n2 n3)).
658 intro.
659 elim n4. apply eq_f.
660 apply (H n3 (S i)).
661 simplify in H4.
662 rewrite > plus_n_O.
663 rewrite > (plus_n_O (defactorize_aux n3 (S i))).assumption.
664 apply False_ind.
665 apply (not_eq_nf_cons_O_nf_cons n1 n3 n5 i).assumption.
666 intros.
667 apply False_ind.
668 apply (not_eq_nf_cons_O_nf_cons n3 n1 n4 i).
669 apply sym_eq.assumption.
670 intros.
671 cut (nf_cons n4 n1 = nf_cons m n3).
672 cut (n4=m).
673 cut (n1=n3).
674 rewrite > Hcut1.rewrite > Hcut2.reflexivity.
675 change with 
676 (match nf_cons n4 n1 with
677 [ (nf_last m) \Rightarrow n1
678 | (nf_cons m g) \Rightarrow g ] = n3).
679 rewrite > Hcut.simplify.reflexivity.
680 change with 
681 (match nf_cons n4 n1 with
682 [ (nf_last m) \Rightarrow m
683 | (nf_cons m g) \Rightarrow m ] = m).
684 rewrite > Hcut.simplify.reflexivity.
685 apply H4.simplify in H5.
686 apply (inj_times_r1 (nth_prime i)).
687 apply lt_O_nth_prime_n.
688 rewrite < assoc_times.rewrite < assoc_times.assumption.
689 qed.
690
691 theorem injective_defactorize_aux: \forall i:nat.
692 injective nat_fact nat (\lambda f.defactorize_aux f i).
693 simplify.
694 intros.
695 apply (eq_defactorize_aux_to_eq x y i H).
696 qed.
697
698 theorem injective_defactorize: 
699 injective nat_fact_all nat defactorize.
700 unfold injective.
701 change with (\forall f,g.defactorize f = defactorize g \to f=g).
702 intro.elim f.
703 generalize in match H.elim g.
704 (* zero - zero *)
705 reflexivity.
706 (* zero - one *)
707 simplify in H1.
708 apply False_ind.
709 apply (not_eq_O_S O H1).
710 (* zero - proper *)
711 simplify in H1.
712 apply False_ind.
713 apply (not_le_Sn_n O).
714 rewrite > H1 in \vdash (? ? %).
715 change with (O < defactorize_aux n O).
716 apply lt_O_defactorize_aux.
717 generalize in match H.
718 elim g.
719 (* one - zero *)
720 simplify in H1.
721 apply False_ind.
722 apply (not_eq_O_S O).apply sym_eq. assumption.
723 (* one - one *)
724 reflexivity.
725 (* one - proper *)
726 simplify in H1.
727 apply False_ind.
728 apply (not_le_Sn_n (S O)).
729 rewrite > H1 in \vdash (? ? %).
730 change with ((S O) < defactorize_aux n O).
731 apply lt_SO_defactorize_aux.
732 generalize in match H.elim g.
733 (* proper - zero *)
734 simplify in H1.
735 apply False_ind.
736 apply (not_le_Sn_n O).
737 rewrite < H1 in \vdash (? ? %).
738 change with (O < defactorize_aux n O).
739 apply lt_O_defactorize_aux.
740 (* proper - one *)
741 simplify in H1.
742 apply False_ind.
743 apply (not_le_Sn_n (S O)).
744 rewrite < H1 in \vdash (? ? %).
745 change with ((S O) < defactorize_aux n O).
746 apply lt_SO_defactorize_aux.
747 (* proper - proper *)
748 apply eq_f.
749 apply (injective_defactorize_aux O).
750 exact H1.
751 qed.
752
753 theorem factorize_defactorize: 
754 \forall f: nat_fact_all. factorize (defactorize f) = f.
755 intros.
756 apply injective_defactorize.
757 apply defactorize_factorize.
758 qed.