Datasets:
Tasks:
Text Generation
Modalities:
Text
Sub-tasks:
language-modeling
Languages:
English
Size:
100K - 1M
License:
| (* ========================================================================= *) | |
| (* The multiplicative group of integers modulo n. *) | |
| (* ========================================================================= *) | |
| needs "Library/grouptheory.ml";; | |
| needs "Library/primitive.ml";; | |
| (* ------------------------------------------------------------------------- *) | |
| (* A trivial general lemma used to dispose of degnerate cases. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let MULT_EQ_2 = prove | |
| (`!m n. m * n = 2 <=> m = 1 /\ n = 2 \/ m = 2 /\ n = 1`, | |
| REPEAT GEN_TAC THEN | |
| ASM_CASES_TAC `m = 0` THEN ASM_REWRITE_TAC[MULT_CLAUSES; ARITH] THEN | |
| ASM_CASES_TAC `n = 0` THEN ASM_REWRITE_TAC[MULT_CLAUSES; ARITH] THEN | |
| ASM_CASES_TAC `m = 1` THEN ASM_REWRITE_TAC[MULT_CLAUSES; ARITH] THEN | |
| ASM_CASES_TAC `n = 1` THEN ASM_REWRITE_TAC[MULT_CLAUSES; ARITH] THEN | |
| MATCH_MP_TAC(ARITH_RULE `2 * 2 <= p ==> ~(p = 2)`) THEN | |
| MATCH_MP_TAC LE_MULT2 THEN ASM_ARITH_TAC);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Multiplicative group of integers mod n, with degenerate {1} for n <= 1. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let modmul_group = new_definition | |
| `modmul_group n = | |
| if n <= 1 then singleton_group 1 | |
| else group({m | m < n /\ coprime(m,n)}, | |
| 1,inverse_mod n,(\a b. (a * b) MOD n))`;; | |
| let MODMUL_GROUP = prove | |
| (`(!n. group_carrier(modmul_group n) = | |
| if n <= 1 then {1} else {m | m < n /\ coprime(m,n)}) /\ | |
| (!n. group_id(modmul_group n) = 1) /\ | |
| (!n. group_inv(modmul_group n) = inverse_mod n) /\ | |
| (!n. group_mul(modmul_group n) = | |
| if n <= 1 then (\a b. 1) else (\a b. (a * b) MOD n))`, | |
| REWRITE_TAC[AND_FORALL_THM] THEN X_GEN_TAC `n:num` THEN | |
| REWRITE_TAC[modmul_group] THEN | |
| ASM_CASES_TAC `n <= 1` THEN ASM_REWRITE_TAC[] THENL | |
| [REWRITE_TAC[SINGLETON_GROUP] THEN ASM_REWRITE_TAC[FUN_EQ_THM; inverse_mod]; | |
| RULE_ASSUM_TAC(REWRITE_RULE[ARITH_RULE `~(n <= 1) <=> 2 <= n`])] THEN | |
| REWRITE_TAC[group_carrier; group_id; group_inv; group_mul] THEN | |
| REWRITE_TAC[GSYM PAIR_EQ; GSYM(CONJUNCT2 group_tybij)] THEN | |
| ASM_REWRITE_TAC[IN_ELIM_THM; ARITH_RULE `1 < n <=> 2 <= n`] THEN | |
| REWRITE_TAC[NUMBER_RULE `coprime(1,n)`; PAIR_EQ] THEN | |
| REPEAT CONJ_TAC THENL | |
| [X_GEN_TAC `m:num` THEN STRIP_TAC THEN | |
| ASM_REWRITE_TAC[INVERSE_MOD_BOUND] THEN | |
| MATCH_MP_TAC(NUMBER_RULE `!m. (a * m == 1) (mod n) ==> coprime(a,n)`) THEN | |
| EXISTS_TAC `m:num` THEN REWRITE_TAC[INVERSE_MOD_LMUL_EQ] THEN | |
| ASM_MESON_TAC[COPRIME_SYM]; | |
| REWRITE_TAC[COPRIME_LMOD; COPRIME_LMUL] THEN | |
| ASM_SIMP_TAC[MOD_LT_EQ; ARITH_RULE `2 <= n ==> ~(n = 0)`]; | |
| REPEAT STRIP_TAC THEN ONCE_REWRITE_TAC[GSYM MOD_MULT_MOD2] THEN | |
| REWRITE_TAC[MOD_MOD_REFL] THEN REWRITE_TAC[MOD_MULT_MOD2] THEN | |
| REWRITE_TAC[MULT_ASSOC]; | |
| SIMP_TAC[MULT_CLAUSES; MOD_LT]; | |
| REWRITE_TAC[MOD_UNIQUE; INVERSE_MOD_RMUL_EQ; INVERSE_MOD_LMUL_EQ] THEN | |
| ASM_SIMP_TAC[ARITH_RULE `2 <= n ==> 1 < n`] THEN | |
| MESON_TAC[COPRIME_SYM]]);; | |
| let FINITE_MODMUL_GROUP = prove | |
| (`!n. FINITE(group_carrier(modmul_group n))`, | |
| GEN_TAC THEN REWRITE_TAC[MODMUL_GROUP] THEN | |
| COND_CASES_TAC THEN ASM_REWRITE_TAC[FINITE_SING] THEN | |
| MATCH_MP_TAC FINITE_SUBSET THEN EXISTS_TAC `0..n` THEN | |
| REWRITE_TAC[FINITE_NUMSEG; SUBSET; IN_ELIM_THM; IN_NUMSEG] THEN | |
| ARITH_TAC);; | |
| let ORDER_MODMUL_GROUP = prove | |
| (`!n. CARD(group_carrier(modmul_group n)) = | |
| if n = 0 then 1 else phi n`, | |
| GEN_TAC THEN COND_CASES_TAC THEN | |
| ASM_REWRITE_TAC[MODMUL_GROUP; LE_0; CARD_SING] THEN | |
| ASM_CASES_TAC `n = 1` THEN ASM_REWRITE_TAC[LE_REFL; PHI_1; CARD_SING] THEN | |
| ASM_REWRITE_TAC[ARITH_RULE `n <= 1 <=> n = 0 \/ n = 1`] THEN | |
| ONCE_REWRITE_TAC[CONJ_SYM] THEN REWRITE_TAC[PHI_ALT]);; | |
| let HAS_SIZE_MODMUL_GROUP = prove | |
| (`!n. ~(n = 0) ==> group_carrier(modmul_group n) HAS_SIZE phi n`, | |
| SIMP_TAC[HAS_SIZE; FINITE_MODMUL_GROUP] THEN | |
| SIMP_TAC[ORDER_MODMUL_GROUP]);; | |
| let ABELIAN_MODMUL_GROUP = prove | |
| (`!n. abelian_group(modmul_group n)`, | |
| GEN_TAC THEN REWRITE_TAC[abelian_group; MODMUL_GROUP] THEN | |
| REPEAT GEN_TAC THEN COND_CASES_TAC THEN ASM_REWRITE_TAC[] THEN | |
| REWRITE_TAC[MULT_SYM]);; | |
| let TRIVIAL_MODMUL_GROUP = prove | |
| (`!n. trivial_group(modmul_group n) <=> n <= 2`, | |
| GEN_TAC THEN REWRITE_TAC[TRIVIAL_GROUP_HAS_SIZE_1; HAS_SIZE] THEN | |
| REWRITE_TAC[FINITE_MODMUL_GROUP] THEN | |
| REWRITE_TAC[ORDER_MODMUL_GROUP] THEN | |
| COND_CASES_TAC THEN ASM_REWRITE_TAC[ARITH] THEN | |
| ASM_CASES_TAC `n = 1` THEN ASM_REWRITE_TAC[PHI_1; ARITH] THEN | |
| ASM_CASES_TAC `n = 2` THEN ASM_REWRITE_TAC[PHI_2; ARITH] THEN | |
| MATCH_MP_TAC(ARITH_RULE `~(n <= 2) /\ 2 <= p ==> (p = 1 <=> n <= 2)`) THEN | |
| CONJ_TAC THENL [ALL_TAC; MATCH_MP_TAC PHI_LOWERBOUND_2] THEN | |
| ASM_ARITH_TAC);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Chinese remainder theorem in group-theoretic language. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let GROUP_HOMOMORPHISM_PROD_MODMUL_GROUP = prove | |
| (`!m n. 2 <= m /\ 2 <= n | |
| ==> group_homomorphism (modmul_group(m * n), | |
| prod_group (modmul_group m) | |
| (modmul_group n)) | |
| (\a. (a MOD m),(a MOD n))`, | |
| REPEAT STRIP_TAC THEN | |
| REWRITE_TAC[GROUP_HOMOMORPHISM; PROD_GROUP; SUBSET] THEN | |
| REWRITE_TAC[FORALL_IN_IMAGE; FORALL_PAIR_THM; IN_CROSS] THEN | |
| REWRITE_TAC[MODMUL_GROUP] THEN | |
| REWRITE_TAC[ARITH_RULE `n <= 1 <=> n = 0 \/ n = 1`] THEN | |
| ASM_SIMP_TAC[MULT_EQ_0; MULT_EQ_1; IN_ELIM_THM; MOD_LT_EQ; COPRIME_LMOD; | |
| PAIR_EQ; ARITH_RULE `2 <= n ==> ~(n = 0) /\ ~(n = 1)`] THEN | |
| SIMP_TAC[COPRIME_RMUL; MOD_MOD; ONCE_REWRITE_RULE[MULT_SYM] MOD_MOD] THEN | |
| REWRITE_TAC[MOD_MULT_MOD2]);; | |
| let GROUP_ISOMORPHISM_PROD_MODMUL_GROUP = prove | |
| (`!m n. 2 <= m /\ 2 <= n /\ coprime(m,n) | |
| ==> group_isomorphism (modmul_group(m * n), | |
| prod_group (modmul_group m) | |
| (modmul_group n)) | |
| (\a. (a MOD m),(a MOD n))`, | |
| REPEAT STRIP_TAC THEN | |
| W(MP_TAC o PART_MATCH (lhand o rand) | |
| GROUP_ISOMORPHISM_EQ_MONOMORPHISM_FINITE o snd) THEN | |
| ASM_SIMP_TAC[ORDER_MODMUL_GROUP; FINITE_PROD_GROUP; | |
| FINITE_MODMUL_GROUP; MULT_EQ_0; | |
| CONJUNCT1 PROD_GROUP; CARD_CROSS; PHI_MULTIPLICATIVE; | |
| ARITH_RULE `2 <= n ==> ~(n = 0)`] THEN | |
| DISCH_THEN SUBST1_TAC THEN REWRITE_TAC[group_monomorphism] THEN | |
| ASM_SIMP_TAC[GROUP_HOMOMORPHISM_PROD_MODMUL_GROUP] THEN | |
| ASM_SIMP_TAC[MODMUL_GROUP; MULT_EQ_0; MULT_EQ_1; | |
| ARITH_RULE `n <= 1 <=> n = 0 \/ n = 1`; | |
| ARITH_RULE `2 <= n ==> ~(n = 0) /\ ~(n = 1)`] THEN | |
| REWRITE_TAC[PAIR_EQ; IN_ELIM_THM; GSYM CONG] THEN | |
| REPEAT STRIP_TAC THEN MATCH_MP_TAC CONG_IMP_EQ THEN | |
| EXISTS_TAC `m * n:num` THEN ASM_REWRITE_TAC[] THEN | |
| ASM_MESON_TAC[NUMBER_RULE | |
| `coprime(m:num,n) /\ (x == y) (mod m) /\ (x == y) (mod n) | |
| ==> (x == y) (mod(m * n))`]);; | |
| let ISOMORPHIC_GROUP_MODMUL_GROUP = prove | |
| (`!m n. coprime(m,n) | |
| ==> prod_group (modmul_group m) | |
| (modmul_group n) | |
| isomorphic_group (modmul_group (m * n))`, | |
| REPEAT STRIP_TAC THEN MATCH_MP_TAC(MESON[ISOMORPHIC_TRIVIAL_GROUPS] | |
| `(trivial_group G <=> trivial_group H) /\ | |
| (~trivial_group G /\ ~trivial_group H ==> G isomorphic_group H) | |
| ==> G isomorphic_group H`) THEN | |
| REWRITE_TAC[TRIVIAL_PROD_GROUP; TRIVIAL_MODMUL_GROUP] THEN | |
| POP_ASSUM MP_TAC THEN | |
| ASM_CASES_TAC `m = 0` THEN ASM_SIMP_TAC[COPRIME_0; ARITH] THEN | |
| ASM_CASES_TAC `n = 0` THEN ASM_SIMP_TAC[COPRIME_0; ARITH] THEN | |
| DISCH_TAC THEN | |
| ASM_CASES_TAC `m = 1` THEN | |
| ASM_SIMP_TAC[MULT_CLAUSES; ISOMORPHIC_PROD_TRIVIAL_GROUP; | |
| TRIVIAL_MODMUL_GROUP; ARITH] THEN | |
| ASM_CASES_TAC `n = 1` THEN | |
| ASM_SIMP_TAC[MULT_CLAUSES; ISOMORPHIC_PROD_TRIVIAL_GROUP; | |
| TRIVIAL_MODMUL_GROUP; ARITH] THEN | |
| ASM_REWRITE_TAC[ARITH_RULE `n <= 2 <=> n = 0 \/ n = 1 \/ n = 2`] THEN | |
| ASM_REWRITE_TAC[MULT_EQ_0; MULT_EQ_1; MULT_EQ_2] THEN | |
| CONJ_TAC THENL [ASM_MESON_TAC[COPRIME_REFL]; DISCH_THEN(K ALL_TAC)] THEN | |
| ONCE_REWRITE_TAC[ISOMORPHIC_GROUP_SYM] THEN | |
| REWRITE_TAC[isomorphic_group] THEN | |
| EXISTS_TAC `\a. (a MOD m),(a MOD n)` THEN | |
| MATCH_MP_TAC GROUP_ISOMORPHISM_PROD_MODMUL_GROUP THEN | |
| ASM_REWRITE_TAC[] THEN ASM_ARITH_TAC);; | |
| let GROUP_POW_MODMUL_GROUP = prove | |
| (`!n a k. group_pow (modmul_group n) a k = | |
| if n <= 1 then 1 else (a EXP k) MOD n`, | |
| GEN_TAC THEN GEN_TAC THEN INDUCT_TAC THEN | |
| ASM_REWRITE_TAC[group_pow; MODMUL_GROUP] THEN | |
| COND_CASES_TAC THEN ASM_REWRITE_TAC[EXP] THENL | |
| [CONV_TAC SYM_CONV THEN MATCH_MP_TAC MOD_LT THEN ASM_ARITH_TAC; | |
| MESON_TAC[MOD_MULT_MOD2; MOD_MOD_REFL; MOD_EXP_MOD]]);; | |
| let GROUP_ELEMENT_ORDER_MODMUL_GROUP = prove | |
| (`!n a. a IN group_carrier(modmul_group n) | |
| ==> group_element_order (modmul_group n) a = order n a`, | |
| REPEAT STRIP_TAC THEN | |
| ASM_SIMP_TAC[GROUP_ELEMENT_ORDER_UNIQUE] THEN | |
| REWRITE_TAC[GSYM ORDER_DIVIDES] THEN | |
| X_GEN_TAC `k:num` THEN POP_ASSUM MP_TAC THEN | |
| REWRITE_TAC[GROUP_POW_MODMUL_GROUP] THEN | |
| REWRITE_TAC[MODMUL_GROUP] THEN | |
| COND_CASES_TAC THEN ASM_SIMP_TAC[IN_SING; EXP_ONE; CONG] THEN | |
| DISCH_THEN(K ALL_TAC) THEN RULE_ASSUM_TAC(REWRITE_RULE[NOT_LE]) THEN | |
| ASM_SIMP_TAC[MOD_LT]);; | |
| (* ------------------------------------------------------------------------- *) | |
| (* Existence of primitive roots in group-theoretic language. *) | |
| (* ------------------------------------------------------------------------- *) | |
| let CYCLIC_MODMUL_GROUP = prove | |
| (`!n. cyclic_group(modmul_group n) <=> | |
| n = 0 \/ n = 1 \/ n = 2 \/ n = 4 \/ | |
| ?p k. prime p /\ 3 <= p /\ (n = p EXP k \/ n = 2 * p EXP k)`, | |
| GEN_TAC THEN ASM_CASES_TAC `n <= 2` THENL | |
| [ASM_SIMP_TAC[TRIVIAL_MODMUL_GROUP; | |
| TRIVIAL_IMP_CYCLIC_GROUP] THEN | |
| ASM_ARITH_TAC; | |
| RULE_ASSUM_TAC(REWRITE_RULE[NOT_LE])] THEN | |
| SIMP_TAC[CYCLIC_GROUP_ELEMENT_ORDER; FINITE_MODMUL_GROUP] THEN | |
| ONCE_REWRITE_TAC[TAUT `p /\ q <=> ~(p ==> ~q)`] THEN | |
| SIMP_TAC[GROUP_ELEMENT_ORDER_MODMUL_GROUP] THEN | |
| MP_TAC(SPEC `n:num` PRIMITIVE_ROOT_EXISTS) THEN | |
| ASM_SIMP_TAC[ORDER_MODMUL_GROUP; FINITE_MODMUL_GROUP; | |
| MODMUL_GROUP; | |
| ARITH_RULE `2 < n ==> ~(n = 0) /\ ~(n = 1) /\ ~(n <= 1)`] THEN | |
| REWRITE_TAC[IN_ELIM_THM; NOT_IMP] THEN DISCH_THEN(SUBST1_TAC o SYM) THEN | |
| EQ_TAC THENL [MESON_TAC[]; ALL_TAC] THEN | |
| DISCH_THEN(X_CHOOSE_THEN `k:num` STRIP_ASSUME_TAC) THEN | |
| EXISTS_TAC `k MOD n` THEN | |
| ASM_SIMP_TAC[MOD_LT_EQ; ARITH_RULE `2 < n ==> ~(n = 0)`] THEN | |
| MATCH_MP_TAC(TAUT `(~p ==> ~q) /\ q ==> p /\ q`) THEN | |
| ONCE_REWRITE_TAC[COPRIME_SYM] THEN SIMP_TAC[GSYM ORDER_EQ_0] THEN | |
| GEN_REWRITE_TAC (LAND_CONV o ONCE_DEPTH_CONV) [EQ_SYM_EQ] THEN | |
| ASM_SIMP_TAC[PHI_EQ_0; ARITH_RULE `2 < n ==> ~(n = 0)`] THEN | |
| FIRST_X_ASSUM(SUBST1_TAC o SYM) THEN MATCH_MP_TAC ORDER_CONG THEN | |
| REWRITE_TAC[CONG_LMOD; CONG_REFL]);; | |