(* *)
(**************************************************************************)
-set "baseuri" "cic:/matita/library_auto/nat/factorization".
+set "baseuri" "cic:/matita/library_autobatch/nat/factorization".
include "auto/nat/ord.ma".
include "auto/nat/gcd.ma".
apply (ex_intro nat ? a).
split
[ apply (trans_le a (nth_prime a))
- [ auto
+ [ autobatch
(*apply le_n_fn.
exact lt_nth_prime_n_nth_prime_Sn*)
| rewrite > H1.
(*CSC: simplify here does something nasty! *)
change with (divides_b (smallest_factor n) n = true).
apply divides_to_divides_b_true
- [ auto
+ [ autobatch
(*apply (trans_lt ? (S O))
[ unfold lt.
apply le_n
| apply lt_SO_smallest_factor.
assumption
]*)
- | auto
+ | autobatch
(*letin x \def le.
- auto new*)
+ autobatch new*)
(*
apply divides_smallest_factor_n;
apply (trans_lt ? (S O));
| assumption; ] *)
]
]
- | auto
+ | autobatch
(*
apply prime_to_nth_prime;
apply prime_smallest_factor_n;
intros.
unfold max_prime_factor.
apply f_m_to_le_max
-[ auto
+[ autobatch
(*apply (trans_le ? n)
[ apply le_max_n
| apply divides_to_le;assumption
]*)
| change with (divides_b (nth_prime (max_prime_factor n)) m = true).
apply divides_to_divides_b_true
- [ auto
+ [ autobatch
(*cut (prime (nth_prime (max_prime_factor n)))
[ apply lt_O_nth_prime_n
| apply prime_nth_prime
]*)
- | auto
+ | autobatch
(*cut (nth_prime (max_prime_factor n) \divides n)
- [ auto
- | auto
+ [ autobatch
+ | autobatch
] *)
(*
[ apply (transitive_divides ? n);
[ assumption
| absurd (nth_prime (max_prime_factor n) \divides r)
[ rewrite < H4.
- auto
+ autobatch
(*apply divides_max_prime_factor_n.
assumption*)
| unfold Not.
intro.
cut (r \mod (nth_prime (max_prime_factor n)) \neq O)
- [ auto
+ [ autobatch
(*unfold Not in Hcut1.
- auto new*)
+ autobatch new*)
(*
apply Hcut1.apply divides_to_mod_O;
[ apply lt_O_nth_prime_n.
[ 2: rewrite < H1.
assumption
| letin x \def le.
- auto width = 4 new
+ autobatch width = 4 new
]
(* CERCA COME MAI le_n non lo applica se lo trova come Const e non Rel *)
]
| assumption
| apply (witness r n ((nth_prime p) \sup q)).
rewrite > sym_times.
- (*qui auto non chiude il goal*)
+ (*qui autobatch non chiude il goal*)
apply (p_ord_aux_to_exp n n)
[ apply lt_O_nth_prime_n.
| assumption
]
| assumption
]
- | apply (p_ord_to_lt_max_prime_factor n ? q);auto
+ | apply (p_ord_to_lt_max_prime_factor n ? q);autobatch
(*[ assumption
| apply sym_eq.
assumption
[1,2:
simplify;
unfold lt;
- rewrite > times_n_SO;auto
+ rewrite > times_n_SO;autobatch
(*apply le_times
[ change with (O < nth_prime i).
apply lt_O_nth_prime_n
[ simplify.
unfold lt.
rewrite > times_n_SO.
- auto
+ autobatch
(*apply le_times
[ change with (S O < nth_prime i).
apply lt_SO_nth_prime_n
unfold lt.
rewrite > times_n_SO.
rewrite > sym_times.
- auto
+ autobatch
(*apply le_times
[ change with (O < exp (nth_prime i) n).
apply lt_O_exp.
[ simplify.
elim H1
[ elim H2.
- auto
+ autobatch
(*rewrite > H3.
rewrite > sym_times.
apply times_n_SO*)
defactorize_aux match (p_ord_aux n1 n1 (nth_prime n)) with
[(pair q r) \Rightarrow (factorize_aux n r (nf_cons q acc))] O =
n1*defactorize_aux acc (S n))
- [ (*invocando auto in questo punto, dopo circa 7 minuti l'esecuzione non era ancora terminata
+ [ (*invocando autobatch in questo punto, dopo circa 7 minuti l'esecuzione non era ancora terminata
ne' con un errore ne' chiudendo il goal
*)
apply (Hcut (fst ? ? (p_ord_aux n1 n1 (nth_prime n)))
(snd ? ? (p_ord_aux n1 n1 (nth_prime n)))).
- auto
+ autobatch
(*apply sym_eq.apply eq_pair_fst_snd*)
| intros.
rewrite < H3.
cut (n1 = r * (nth_prime n) \sup q)
[ rewrite > H
[ simplify.
- auto
+ autobatch
(*rewrite < assoc_times.
rewrite < Hcut.
reflexivity.*)
- | auto
+ | autobatch
(*cut (O < r \lor O = r)
[ elim Hcut1
[ assumption
[ elim H5.
apply False_ind.
apply (not_eq_O_S n).
- auto
+ autobatch
(*apply sym_eq.
assumption*)
- | auto
+ | autobatch
(*apply le_S_S_to_le.
exact H5*)
]
]
| cut (r=(S O))
[ apply (nat_case n)
- [ auto
+ [ autobatch
(*left.
split
[ assumption
| intro.
right.
rewrite > Hcut2.
- auto
+ autobatch
(*simplify.
unfold lt.
apply le_S_S.
| cut (r < (S O) ∨ r=(S O))
[ elim Hcut2
[ absurd (O=r)
- [ auto
+ [ autobatch
(*apply le_n_O_to_eq.
apply le_S_S_to_le.
exact H5*)
| unfold Not.
intro.
- auto
+ autobatch
(*cut (O=n1)
[ apply (not_le_Sn_O O).
rewrite > Hcut3 in ⊢ (? ? %).
]
| assumption
]
- | auto
+ | autobatch
(*apply (le_to_or_lt_eq r (S O)).
apply not_lt_to_le.
assumption*)
defactorize (match p_ord (S(S m1)) (nth_prime p) with
[ (pair q r) \Rightarrow
nfa_proper (factorize_aux p r (nf_last (pred q)))])=(S(S m1)))
- [ (*invocando auto qui, dopo circa 300 secondi non si ottiene alcun risultato*)
+ [ (*invocando autobatch qui, dopo circa 300 secondi non si ottiene alcun risultato*)
apply (Hcut (fst ? ? (p_ord (S(S m1)) (nth_prime p)))
(snd ? ? (p_ord (S(S m1)) (nth_prime p)))).
- auto
+ autobatch
(*apply sym_eq.
apply eq_pair_fst_snd*)
| intros.
[ (*CSC: simplify here does something really nasty *)
change with (r*(nth_prime p) \sup (S (pred q)) = (S(S m1))).
cut ((S (pred q)) = q)
- [ (*invocando auto qui, dopo circa 300 secondi non si ottiene ancora alcun risultato*)
+ [ (*invocando autobatch qui, dopo circa 300 secondi non si ottiene ancora alcun risultato*)
rewrite > Hcut2.
- auto
+ autobatch
(*rewrite > sym_times.
apply sym_eq.
apply (p_ord_aux_to_exp (S(S m1)))
[ assumption
| absurd (nth_prime p \divides S (S m1))
[ apply (divides_max_prime_factor_n (S (S m1))).
- auto
+ autobatch
(*unfold lt.
apply le_S_S.
apply le_S_S.
change with (nth_prime p \divides r \to False).
intro.
apply (p_ord_aux_to_not_mod_O (S(S m1)) (S(S m1)) (nth_prime p) q r) [ apply lt_SO_nth_prime_n
- | auto
+ | autobatch
(*unfold lt.
apply le_S_S.
apply le_O_n*)
| apply le_n
| assumption
- | (*invocando auto qui, dopo circa 300 secondi non si ottiene ancora alcun risultato*)
+ | (*invocando autobatch qui, dopo circa 300 secondi non si ottiene ancora alcun risultato*)
apply divides_to_mod_O
[ apply lt_O_nth_prime_n
| assumption
]
]
]
- | auto
+ | autobatch
(*apply le_to_or_lt_eq.
apply le_O_n*)
]
cut ((S O) < r \lor S O \nlt r)
[ elim Hcut2
[ right.
- apply (p_ord_to_lt_max_prime_factor1 (S(S m1)) ? q r);auto
+ apply (p_ord_to_lt_max_prime_factor1 (S(S m1)) ? q r);autobatch
(*[ unfold lt.
apply le_S_S.
apply le_O_n
]*)
| cut (r=(S O))
[ apply (nat_case p)
- [ auto
+ [ autobatch
(*left.
split
[ assumption
| intro.
right.
rewrite > Hcut3.
- auto
+ autobatch
(*simplify.
unfold lt.
apply le_S_S.
]
| cut (r \lt (S O) \or r=(S O))
[ elim Hcut3
- [ absurd (O=r);auto
+ [ absurd (O=r);autobatch
(*[ apply le_n_O_to_eq.
apply le_S_S_to_le.
exact H2
]*)
| assumption
]
- | auto
+ | autobatch
(*apply (le_to_or_lt_eq r (S O)).
apply not_lt_to_le.
assumption*)
apply (not_eq_O_S (S m1)).
rewrite > Hcut.
rewrite < H1.
- auto
+ autobatch
(*rewrite < times_n_O.
reflexivity*)
]
- | auto
+ | autobatch
(*apply le_to_or_lt_eq.
apply le_O_n*)
]
]
| (* prova del cut *)
- apply (p_ord_aux_to_exp (S(S m1)));auto
+ apply (p_ord_aux_to_exp (S(S m1)));autobatch
(*[ apply lt_O_nth_prime_n
| assumption
]*)
intro.
elim f
[ simplify.
- auto
+ autobatch
(*apply (witness ? ? ((nth_prime i) \sup n)).
reflexivity*)
| change with
rewrite > H1.
rewrite < sym_times.
rewrite > assoc_times.
- auto
+ autobatch
(*rewrite < plus_n_Sm.
apply (witness ? ? (n2* (nth_prime i) \sup n)).
reflexivity*)
intros 3.
elim m
[ simplify in H1.
- auto
+ autobatch
(*apply (transitive_divides p (S O))
[ assumption
| apply divides_SO_n
| cut (p \divides n \lor p \divides n \sup n1)
[ elim Hcut
[ assumption
- | auto
+ | autobatch
(*apply H;assumption*)
]
- | auto
+ | autobatch
(*apply divides_times_to_divides
[ assumption
| exact H2
elim H1.
apply H4
[ apply (divides_exp_to_divides p q m);assumption
-| (*invocando auto in questo punto, dopo piu' di 8 minuti la computazione non
+| (*invocando autobatch in questo punto, dopo piu' di 8 minuti la computazione non
* era ancora terminata.
*)
unfold prime in H.
- (*invocando auto anche in questo punto, dopo piu' di 10 minuti la computazione
+ (*invocando autobatch anche in questo punto, dopo piu' di 10 minuti la computazione
* non era ancora terminata.
*)
elim H.
(nth_prime i \divides (nth_prime j) \sup (S n) \to False).
intro.
absurd ((nth_prime i) = (nth_prime j))
- [ apply (divides_exp_to_eq ? ? (S n));auto
+ [ apply (divides_exp_to_eq ? ? (S n));autobatch
(*[ apply prime_nth_prime
| apply prime_nth_prime
| assumption
\lor nth_prime i \divides defactorize_aux n1 (S j))
[ elim Hcut
[ absurd ((nth_prime i) = (nth_prime j))
- [ apply (divides_exp_to_eq ? ? n);auto
+ [ apply (divides_exp_to_eq ? ? n);autobatch
(*[ apply prime_nth_prime
| apply prime_nth_prime
| assumption
]
]
| apply (H i (S j))
- [ auto
+ [ autobatch
(*apply (trans_lt ? j)
[ assumption
| unfold lt.
| assumption
]
]
- | auto
+ | autobatch
(*apply divides_times_to_divides.
apply prime_nth_prime.
assumption*)
intro.
cut (S(max_p g)+i= i)
[ apply (not_le_Sn_n i).
- rewrite < Hcut in \vdash (? ? %). (*chiamando auto qui da uno strano errore "di tipo"*)
+ rewrite < Hcut in \vdash (? ? %). (*chiamando autobatch qui da uno strano errore "di tipo"*)
simplify.
- auto
+ autobatch
(*apply le_S_S.
apply le_plus_n*)
| apply injective_nth_prime.
rewrite < plus_n_O.
intro.
apply (not_divides_defactorize_aux f i (S i) ?)
-[ auto
+[ autobatch
(*unfold lt.
apply le_n*)
-| auto
+| autobatch
(*rewrite > H.
rewrite > assoc_times.
apply (witness ? ? ((exp (nth_prime i) n)*(defactorize_aux g (S i)))).
apply inj_S.
apply (inj_exp_r (nth_prime i))
[ apply lt_SO_nth_prime_n
- | (*qui auto non conclude il goal attivo*)
+ | (*qui autobatch non conclude il goal attivo*)
assumption
]
| apply False_ind.
- (*auto chiamato qui NON conclude il goal attivo*)
+ (*autobatch chiamato qui NON conclude il goal attivo*)
apply (not_eq_nf_last_nf_cons n2 n n1 i H2)
]
| generalize in match H1.
elim g
[ apply False_ind.
apply (not_eq_nf_last_nf_cons n1 n2 n i).
- auto
+ autobatch
(*apply sym_eq.
assumption*)
| simplify in H3.
nf_cons n n1 = nf_cons n2 n3))
[ intro.
elim n4
- [ auto
+ [ autobatch
(*apply eq_f.
apply (H n3 (S i))
simplify in H4.
assumption*)
| apply False_ind.
apply (not_eq_nf_cons_O_nf_cons n1 n3 n5 i).
- (*auto chiamato qui NON chiude il goal attivo*)
+ (*autobatch chiamato qui NON chiude il goal attivo*)
assumption
]
| intros.
apply False_ind.
apply (not_eq_nf_cons_O_nf_cons n3 n1 n4 i).
apply sym_eq.
- (*auto chiamato qui non chiude il goal*)
+ (*autobatch chiamato qui non chiude il goal*)
assumption
| intros.
cut (nf_cons n4 n1 = nf_cons m n3)
[ cut (n4=m)
[ cut (n1=n3)
- [ auto
+ [ autobatch
(*rewrite > Hcut1.
rewrite > Hcut2.
reflexivity*)
[ (nf_last m) \Rightarrow n1
| (nf_cons m g) \Rightarrow g ] = n3).
rewrite > Hcut.
- auto
+ autobatch
(*simplify.
reflexivity*)
]
(match nf_cons n4 n1 with
[ (nf_last m) \Rightarrow m
| (nf_cons m g) \Rightarrow m ] = m).
- (*invocando auto qui, dopo circa 8 minuti la computazione non era ancora terminata*)
+ (*invocando autobatch qui, dopo circa 8 minuti la computazione non era ancora terminata*)
rewrite > Hcut.
- auto
+ autobatch
(*simplify.
reflexivity*)
]
apply False_ind.
apply (not_le_Sn_n O).
rewrite > H1 in \vdash (? ? %).
- auto
+ autobatch
(*change with (O < defactorize_aux n O).
apply lt_O_defactorize_aux*)
]
[ (* one - zero *)
simplify in H1.
apply False_ind.
- auto
+ autobatch
(*apply (not_eq_O_S O).
apply sym_eq.
assumption*)
apply False_ind.
apply (not_le_Sn_n (S O)).
rewrite > H1 in \vdash (? ? %).
- auto
+ autobatch
(*change with ((S O) < defactorize_aux n O).
apply lt_SO_defactorize_aux*)
]
apply False_ind.
apply (not_le_Sn_n O).
rewrite < H1 in \vdash (? ? %).
- auto
+ autobatch
(*change with (O < defactorize_aux n O).
apply lt_O_defactorize_aux.*)
| (* proper - one *)
apply False_ind.
apply (not_le_Sn_n (S O)).
rewrite < H1 in \vdash (? ? %).
- auto
+ autobatch
(*change with ((S O) < defactorize_aux n O).
apply lt_SO_defactorize_aux.*)
| (* proper - proper *)
apply eq_f.
apply (injective_defactorize_aux O).
- (*invocata qui la tattica auto NON chiude il goal, chiuso invece
+ (*invocata qui la tattica autobatch NON chiude il goal, chiuso invece
*da exact H1
*)
exact H1
theorem factorize_defactorize:
\forall f,g: nat_fact_all. factorize (defactorize f) = f.
intros.
-auto.
+autobatch.
(*apply injective_defactorize.
apply defactorize_factorize.
*)