srcContext
stringlengths 44
89.6k
| theoremStatement
stringlengths 28
895
| theoremName
stringlengths 3
58
⌀ | fileCreated
stringclasses 15
values | theoremCreated
stringclasses 50
values | file
stringclasses 23
values | positionMetadata
dict | dependencyMetadata
dict | proofMetadata
dict | split
stringclasses 4
values |
---|---|---|---|---|---|---|---|---|---|
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
| lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 | HTPI.mod_succ_lt | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 7,
"tokenPositionInFile": 96,
"theoremPositionInFile": 0
} | {
"inFilePremises": false,
"repositoryPremises": false
} | {
"hasProof": true,
"proof": ":= by\n have h : n + 1 > 0 := Nat.succ_pos n\n show a % (n + 1) < n + 1 from Nat.mod_lt a h\n done",
"proofType": "tactic",
"proofLengthLines": 3,
"proofLengthTokens": 98
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
| theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) | HTPI.dvd_mod_of_dvd_a_b | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 117,
"tokenPositionInFile": 3037,
"theoremPositionInFile": 25
} | {
"inFilePremises": false,
"repositoryPremises": false
} | {
"hasProof": true,
"proof": ":= by\n set q : Nat := a / b\n have h3 : b * q + a % b = a := Nat.div_add_mod a b\n obtain (j : Nat) (h4 : a = d * j) from h1\n obtain (k : Nat) (h5 : b = d * k) from h2\n define --Goal : ∃ (c : Nat), a % b = d * c\n apply Exists.intro (j - k * q)\n show a % b = d * (j - k * q) from\n calc a % b\n _ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm\n _ = a - b * q := by rw [h3]\n _ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]\n _ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm\n done",
"proofType": "tactic",
"proofLengthLines": 13,
"proofLengthTokens": 538
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
| theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a | HTPI.dvd_a_of_dvd_b_mod | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 133,
"tokenPositionInFile": 3662,
"theoremPositionInFile": 26
} | {
"inFilePremises": false,
"repositoryPremises": false
} | {
"hasProof": false,
"proof": ":= sorry",
"proofType": "term",
"proofLengthLines": 0,
"proofLengthTokens": 8
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
| lemma gcd_base (a : Nat) : gcd a 0 = a | HTPI.gcd_base | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 138,
"tokenPositionInFile": 3791,
"theoremPositionInFile": 27
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by rfl",
"proofType": "tactic",
"proofLengthLines": 0,
"proofLengthTokens": 9
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
| lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) | HTPI.gcd_nonzero | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 140,
"tokenPositionInFile": 3841,
"theoremPositionInFile": 28
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h\n rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))\n rfl\n done",
"proofType": "tactic",
"proofLengthLines": 4,
"proofLengthTokens": 158
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
| lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b | HTPI.mod_nonzero_lt | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 147,
"tokenPositionInFile": 4081,
"theoremPositionInFile": 29
} | {
"inFilePremises": false,
"repositoryPremises": false
} | {
"hasProof": true,
"proof": ":= by\n have h1 : b > 0 := Nat.pos_of_ne_zero h\n show a % b < b from Nat.mod_lt a h1\n done",
"proofType": "tactic",
"proofLengthLines": 3,
"proofLengthTokens": 92
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
| lemma dvd_self (n : Nat) : n ∣ n | HTPI.dvd_self | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 152,
"tokenPositionInFile": 4240,
"theoremPositionInFile": 30
} | {
"inFilePremises": false,
"repositoryPremises": false
} | {
"hasProof": true,
"proof": ":= by\n apply Exists.intro 1\n ring\n done",
"proofType": "tactic",
"proofLengthLines": 3,
"proofLengthTokens": 42
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
| theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b | HTPI.gcd_dvd | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 157,
"tokenPositionInFile": 4317,
"theoremPositionInFile": 31
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n by_strong_induc\n fix b : Nat\n assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1\n fix a : Nat\n by_cases h1 : b = 0\n · -- Case 1. h1 : b = 0\n rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0\n apply And.intro (dvd_self a)\n define\n apply Exists.intro 0\n rfl\n done\n · -- Case 2. h1 : b ≠ 0\n rewrite [gcd_nonzero a h1]\n --Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b\n have h2 : a % b < b := mod_nonzero_lt a h1\n have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=\n ih (a % b) h2 b\n apply And.intro _ h3.left\n show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right\n done\n done",
"proofType": "tactic",
"proofLengthLines": 22,
"proofLengthTokens": 670
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
| theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a | HTPI.gcd_dvd_left | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 181,
"tokenPositionInFile": 5052,
"theoremPositionInFile": 32
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= (gcd_dvd b a).left",
"proofType": "term",
"proofLengthLines": 0,
"proofLengthTokens": 21
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
| theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b | HTPI.gcd_dvd_right | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 183,
"tokenPositionInFile": 5124,
"theoremPositionInFile": 33
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= (gcd_dvd b a).right",
"proofType": "term",
"proofLengthLines": 0,
"proofLengthTokens": 22
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
| lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 | HTPI.gcd_c1_base | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 185,
"tokenPositionInFile": 5198,
"theoremPositionInFile": 34
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by rfl",
"proofType": "tactic",
"proofLengthLines": 0,
"proofLengthTokens": 9
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
| lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) | HTPI.gcd_c1_nonzero | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 187,
"tokenPositionInFile": 5254,
"theoremPositionInFile": 35
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h\n rewrite [h2]\n rfl\n done",
"proofType": "tactic",
"proofLengthLines": 4,
"proofLengthTokens": 105
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
| lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 | HTPI.gcd_c2_base | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 194,
"tokenPositionInFile": 5450,
"theoremPositionInFile": 36
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by rfl",
"proofType": "tactic",
"proofLengthLines": 0,
"proofLengthTokens": 9
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
| lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) | HTPI.gcd_c2_nonzero | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 196,
"tokenPositionInFile": 5506,
"theoremPositionInFile": 37
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h\n rewrite [h2]\n rfl\n done",
"proofType": "tactic",
"proofLengthLines": 4,
"proofLengthTokens": 105
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
| theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) | HTPI.gcd_lin_comb | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 203,
"tokenPositionInFile": 5734,
"theoremPositionInFile": 38
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n by_strong_induc\n fix b : Nat\n assume ih : ∀ b_1 < b, ∀ (a : Nat),\n (gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)\n fix a : Nat\n by_cases h1 : b = 0\n · -- Case 1. h1 : b = 0\n rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]\n --Goal : 1 * ↑a + 0 * ↑0 = ↑a\n ring\n done\n · -- Case 2. h1 : b ≠ 0\n rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]\n --Goal : gcd_c2 b (a % b) * ↑a +\n -- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =\n -- ↑(gcd b (a % b))\n set r : Nat := a % b\n set q : Nat := a / b\n set s : Int := gcd_c1 b r\n set t : Int := gcd_c2 b r\n --Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)\n have h2 : r < b := mod_nonzero_lt a h1\n have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b\n have h4 : b * q + r = a := Nat.div_add_mod a b\n rewrite [←h3, ←h4]\n rewrite [Nat.cast_add, Nat.cast_mul]\n --Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r\n ring\n done\n done",
"proofType": "tactic",
"proofLengthLines": 30,
"proofLengthTokens": 1012
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
| theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b | HTPI.Theorem_7_1_6 | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 240,
"tokenPositionInFile": 6972,
"theoremPositionInFile": 39
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)\n set s : Int := gcd_c1 a b\n set t : Int := gcd_c2 a b\n have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a\n rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b\n obtain (j : Nat) (h4 : a = d * j) from h1\n obtain (k : Nat) (h5 : b = d * k) from h2\n rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]\n --Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)\n define\n apply Exists.intro (s * ↑j + t * ↑k)\n ring\n done",
"proofType": "tactic",
"proofLengthLines": 13,
"proofLengthTokens": 494
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
| theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c | HTPI.dvd_trans | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 257,
"tokenPositionInFile": 7566,
"theoremPositionInFile": 40
} | {
"inFilePremises": false,
"repositoryPremises": false
} | {
"hasProof": true,
"proof": ":= by\n define at h1; define at h2; define\n obtain (m : Nat) (h3 : b = a * m) from h1\n obtain (n : Nat) (h4 : c = b * n) from h2\n rewrite [h3, mul_assoc] at h4\n apply Exists.intro (m * n)\n show c = a * (m * n) from h4\n done",
"proofType": "tactic",
"proofLengthLines": 7,
"proofLengthTokens": 229
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
| lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n | HTPI.exists_prime_factor | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 266,
"tokenPositionInFile": 7863,
"theoremPositionInFile": 41
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n by_strong_induc\n fix n : Nat\n assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1\n assume h1 : 2 ≤ n\n by_cases h2 : prime n\n · -- Case 1. h2 : prime n\n apply Exists.intro n\n define --Goal : prime n ∧ n ∣ n\n show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)\n done\n · -- Case 2. h2 : ¬prime n\n define at h2\n --h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)\n demorgan at h2\n disj_syll h2 h1\n obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2\n obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3\n have h5 : 2 ≤ a := by\n by_contra h6\n have h7 : a ≤ 1 := by linarith\n have h8 : n ≤ b :=\n calc n\n _ = a * b := h4.left.symm\n _ ≤ 1 * b := by rel [h7]\n _ = b := by ring\n linarith --n ≤ b contradicts b < n\n done\n have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5\n obtain (p : Nat) (h7 : prime_factor p a) from h6\n apply Exists.intro p\n define --Goal : prime p ∧ p ∣ n\n define at h7 --h7 : prime p ∧ p ∣ a\n apply And.intro h7.left\n have h8 : a ∣ n := by\n apply Exists.intro b\n show n = a * b from (h4.left).symm\n done\n show p ∣ n from dvd_trans h7.right h8\n done\n done",
"proofType": "tactic",
"proofLengthLines": 40,
"proofLengthTokens": 1310
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
| lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q | HTPI.exists_least_prime_factor | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 309,
"tokenPositionInFile": 9258,
"theoremPositionInFile": 42
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n set S : Set Nat := {p : Nat | prime_factor p n}\n have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h\n show ∃ (p : Nat), prime_factor p n ∧\n ∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2\n done",
"proofType": "tactic",
"proofLengthLines": 5,
"proofLengthTokens": 226
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
| lemma all_prime_nil : all_prime [] | HTPI.all_prime_nil | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 318,
"tokenPositionInFile": 9620,
"theoremPositionInFile": 43
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n define --Goal : ∀ p ∈ [], prime p\n fix p : Nat\n contrapos --Goal : ¬prime p → p ∉ []\n assume h1 : ¬prime p\n show p ∉ [] from List.not_mem_nil p\n done",
"proofType": "tactic",
"proofLengthLines": 6,
"proofLengthTokens": 167
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
| lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L | HTPI.all_prime_cons | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 326,
"tokenPositionInFile": 9824,
"theoremPositionInFile": 44
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n apply Iff.intro\n · -- (→)\n assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L\n define at h1 --h1 : ∀ p ∈ n :: L, prime p\n apply And.intro (h1 n (List.mem_cons_self n L))\n define --Goal : ∀ p ∈ L, prime p\n fix p : Nat\n assume h2 : p ∈ L\n show prime p from h1 p (List.mem_cons_of_mem n h2)\n done\n · -- (←)\n assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)\n define : all_prime L at h1\n define\n fix p : Nat\n assume h2 : p ∈ n :: L\n rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L\n by_cases on h2\n · -- Case 1. h2 : p = n\n rewrite [h2]\n show prime n from h1.left\n done\n · -- Case 2. h2 : p ∈ L\n show prime p from h1.right p h2\n done\n done\n done",
"proofType": "tactic",
"proofLengthLines": 27,
"proofLengthTokens": 768
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
| lemma nondec_nil : nondec [] | HTPI.nondec_nil | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 356,
"tokenPositionInFile": 10689,
"theoremPositionInFile": 45
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n define --Goal : True\n trivial --trivial proves some obviously true statements, such as True\n done",
"proofType": "tactic",
"proofLengthLines": 3,
"proofLengthTokens": 108
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
| lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L | HTPI.nondec_cons | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 361,
"tokenPositionInFile": 10828,
"theoremPositionInFile": 46
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by rfl",
"proofType": "tactic",
"proofLengthLines": 0,
"proofLengthTokens": 9
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
| lemma prod_nil : prod [] = 1 | HTPI.prod_nil | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 364,
"tokenPositionInFile": 10934,
"theoremPositionInFile": 47
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by rfl",
"proofType": "tactic",
"proofLengthLines": 0,
"proofLengthTokens": 9
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
| lemma prod_cons : prod (n :: L) = n * (prod L) | HTPI.prod_cons | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 366,
"tokenPositionInFile": 10974,
"theoremPositionInFile": 48
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by rfl",
"proofType": "tactic",
"proofLengthLines": 0,
"proofLengthTokens": 9
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
| lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n | HTPI.exists_cons_of_length_eq_succ | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 368,
"tokenPositionInFile": 11032,
"theoremPositionInFile": 49
} | {
"inFilePremises": false,
"repositoryPremises": false
} | {
"hasProof": true,
"proof": ":= by\n have h1 : ¬l.length = 0 := by linarith\n rewrite [List.length_eq_zero] at h1\n obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from\n List.exists_cons_of_ne_nil h1\n obtain (L : List A) (h3 : l = a :: L) from h2\n apply Exists.intro a\n apply Exists.intro L\n apply And.intro h3\n have h4 : (a :: L).length = L.length + 1 := List.length_cons a L\n rewrite [←h3, h] at h4\n show L.length = n from (Nat.add_right_cancel h4).symm\n done",
"proofType": "tactic",
"proofLengthLines": 12,
"proofLengthTokens": 444
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
| lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l | HTPI.list_elt_dvd_prod_by_length | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 384,
"tokenPositionInFile": 11631,
"theoremPositionInFile": 50
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n by_induc\n · --Base Case\n fix l : List Nat\n assume h1 : l.length = 0\n rewrite [List.length_eq_zero] at h1 --h1 : l = []\n rewrite [h1] --Goal : a ∈ [] → a ∣ prod []\n contrapos\n assume h2 : ¬a ∣ prod []\n show a ∉ [] from List.not_mem_nil a\n done\n · -- Induction Step\n fix n : Nat\n assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l\n fix l : List Nat\n assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l\n obtain (b : Nat) (h2 : ∃ (L : List Nat),\n l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1\n obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2\n have h4 : a ∈ L → a ∣ prod L := ih L h3.right\n assume h5 : a ∈ l\n rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L\n rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L\n by_cases on h5\n · -- Case 1. h5 : a = b\n apply Exists.intro (prod L)\n rewrite [h5]\n rfl\n done\n · -- Case 2. h5 : a ∈ L\n have h6 : a ∣ prod L := h4 h5\n have h7 : prod L ∣ b * prod L := by\n apply Exists.intro b\n ring\n done\n show a ∣ b * prod L from dvd_trans h6 h7\n done\n done\n done",
"proofType": "tactic",
"proofLengthLines": 38,
"proofLengthTokens": 1254
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
| lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l | HTPI.list_elt_dvd_prod | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 425,
"tokenPositionInFile": 13002,
"theoremPositionInFile": 51
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n set n : Nat := l.length\n have h1 : l.length = n := by rfl\n show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h\n done",
"proofType": "tactic",
"proofLengthLines": 4,
"proofLengthTokens": 135
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
| lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l | HTPI.exists_prime_factorization | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 432,
"tokenPositionInFile": 13217,
"theoremPositionInFile": 52
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n by_strong_induc\n fix n : Nat\n assume ih : ∀ n_1 < n, n_1 ≥ 1 →\n ∃ (l : List Nat), prime_factorization n_1 l\n assume h1 : n ≥ 1\n by_cases h2 : n = 1\n · -- Case 1. h2 : n = 1\n apply Exists.intro []\n define\n apply And.intro\n · -- Proof of nondec_prime_list []\n define\n show all_prime [] ∧ nondec [] from\n And.intro all_prime_nil nondec_nil\n done\n · -- Proof of prod [] = n\n rewrite [prod_nil, h2]\n rfl\n done\n done\n · -- Case 2. h2 : n ≠ 1\n have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2\n obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),\n prime_factor q n → p ≤ q) from exists_least_prime_factor h3\n have p_prime_factor : prime_factor p n := h4.left\n define at p_prime_factor\n have p_prime : prime p := p_prime_factor.left\n have p_dvd_n : p ∣ n := p_prime_factor.right\n have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right\n obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n\n have h5 : m ≠ 0 := by\n contradict h1 with h6\n have h7 : n = 0 :=\n calc n\n _ = p * m := n_eq_pm\n _ = p * 0 := by rw [h6]\n _ = 0 := by ring\n rewrite [h7]\n decide\n done\n have m_pos : 0 < m := Nat.pos_of_ne_zero h5\n have m_lt_n : m < n := by\n define at p_prime\n show m < n from\n calc m\n _ < m + m := by linarith\n _ = 2 * m := by ring\n _ ≤ p * m := by rel [p_prime.left]\n _ = n := n_eq_pm.symm\n done\n obtain (L : List Nat) (h6 : prime_factorization m L)\n from ih m m_lt_n m_pos\n define at h6\n have ndpl_L : nondec_prime_list L := h6.left\n define at ndpl_L\n apply Exists.intro (p :: L)\n define\n apply And.intro\n · -- Proof of nondec_prime_list (p :: L)\n define\n apply And.intro\n · -- Proof of all_prime (p :: L)\n rewrite [all_prime_cons]\n show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left\n done\n · -- Proof of nondec (p :: L)\n rewrite [nondec_cons]\n apply And.intro _ ndpl_L.right\n fix q : Nat\n assume q_in_L : q ∈ L\n have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L\n rewrite [h6.right] at h7 --h7 : q ∣ m\n have h8 : m ∣ n := by\n apply Exists.intro p\n rewrite [n_eq_pm]\n ring\n done\n have q_dvd_n : q ∣ n := dvd_trans h7 h8\n have ap_L : all_prime L := ndpl_L.left\n define at ap_L\n have q_prime_factor : prime_factor q n :=\n And.intro (ap_L q q_in_L) q_dvd_n\n show p ≤ q from p_least q q_prime_factor\n done\n done\n · -- Proof of prod (p :: L) = n\n rewrite [prod_cons, h6.right, n_eq_pm]\n rfl\n done\n done\n done",
"proofType": "tactic",
"proofLengthLines": 91,
"proofLengthTokens": 2759
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
| theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b | HTPI.Theorem_7_2_2 | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 526,
"tokenPositionInFile": 16080,
"theoremPositionInFile": 53
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b\n define at h1; define at h2; define\n obtain (j : Nat) (h3 : a * b = c * j) from h1\n set s : Int := gcd_c1 a c\n set t : Int := gcd_c2 a c\n have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a\n rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)\n apply Exists.intro (s * ↑j + t * ↑b)\n show ↑b = ↑c * (s * ↑j + t * ↑b) from\n calc ↑b\n _ = (1 : Int) * ↑b := (one_mul _).symm\n _ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]\n _ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring\n _ = s * (↑c * ↑j) + t * ↑c * ↑b := by\n rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]\n _ = ↑c * (s * ↑j + t * ↑b) := by ring\n done",
"proofType": "tactic",
"proofLengthLines": 17,
"proofLengthTokens": 717
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
| lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b | HTPI.le_nonzero_prod_left | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 546,
"tokenPositionInFile": 16885,
"theoremPositionInFile": 54
} | {
"inFilePremises": false,
"repositoryPremises": false
} | {
"hasProof": true,
"proof": ":= by\n have h1 : b ≠ 0 := by\n contradict h with h1\n rewrite [h1]\n ring\n done\n have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1\n show a ≤ a * b from\n calc a\n = a * 1 := (mul_one a).symm\n _ ≤ a * b := by rel [h2]\n done",
"proofType": "tactic",
"proofLengthLines": 11,
"proofLengthTokens": 239
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
| lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b | HTPI.le_nonzero_prod_right | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 559,
"tokenPositionInFile": 17193,
"theoremPositionInFile": 55
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n rewrite [mul_comm]\n rewrite [mul_comm] at h\n show b ≤ b * a from le_nonzero_prod_left h\n done",
"proofType": "tactic",
"proofLengthLines": 4,
"proofLengthTokens": 104
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
| lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p | HTPI.dvd_prime | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 565,
"tokenPositionInFile": 17367,
"theoremPositionInFile": 56
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": false,
"proof": ":= sorry",
"proofType": "term",
"proofLengthLines": 0,
"proofLengthTokens": 8
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
| lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p | HTPI.rel_prime_of_prime_not_dvd | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 568,
"tokenPositionInFile": 17453,
"theoremPositionInFile": 57
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n have h3 : gcd a p ∣ a := gcd_dvd_left a p\n have h4 : gcd a p ∣ p := gcd_dvd_right a p\n have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4\n have h6 : gcd a p ≠ p := by\n contradict h2 with h6\n rewrite [h6] at h3\n show p ∣ a from h3\n done\n disj_syll h5 h6\n show rel_prime a p from h5\n done",
"proofType": "tactic",
"proofLengthLines": 11,
"proofLengthTokens": 316
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
| theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b | HTPI.Theorem_7_2_3 | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 582,
"tokenPositionInFile": 17865,
"theoremPositionInFile": 58
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n or_right with h3\n have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3\n show p ∣ b from Theorem_7_2_2 h2 h4\n done",
"proofType": "tactic",
"proofLengthLines": 4,
"proofLengthTokens": 131
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
| lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 | HTPI.ge_one_of_prod_one | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 589,
"tokenPositionInFile": 18086,
"theoremPositionInFile": 59
} | {
"inFilePremises": false,
"repositoryPremises": false
} | {
"hasProof": true,
"proof": ":= by\n have h1 : a ≠ 0 := by\n by_contra h1\n rewrite [h1] at h\n contradict h\n linarith\n done\n show a ≥ 1 from Nat.pos_of_ne_zero h1\n done",
"proofType": "tactic",
"proofLengthLines": 8,
"proofLengthTokens": 154
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
| lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 | HTPI.eq_one_of_prod_one | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 599,
"tokenPositionInFile": 18303,
"theoremPositionInFile": 60
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n have h1 : a ≥ 1 := ge_one_of_prod_one h\n have h2 : a * b ≠ 0 := by linarith\n have h3 : a ≤ a * b := le_nonzero_prod_left h2\n rewrite [h] at h3\n show a = 1 from Nat.le_antisymm h3 h1\n done",
"proofType": "tactic",
"proofLengthLines": 6,
"proofLengthTokens": 200
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
| lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 | HTPI.eq_one_of_dvd_one | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 607,
"tokenPositionInFile": 18566,
"theoremPositionInFile": 61
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n obtain (j : Nat) (h1 : 1 = n * j) from h\n show n = 1 from eq_one_of_prod_one h1.symm\n done",
"proofType": "tactic",
"proofLengthLines": 3,
"proofLengthTokens": 100
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
| lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 | HTPI.prime_not_one | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 612,
"tokenPositionInFile": 18722,
"theoremPositionInFile": 62
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n define at h\n linarith\n done",
"proofType": "tactic",
"proofLengthLines": 3,
"proofLengthTokens": 37
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
| theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a | HTPI.Theorem_7_2_4 | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 617,
"tokenPositionInFile": 18813,
"theoremPositionInFile": 63
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n apply List.rec\n · -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a\n rewrite [prod_nil]\n assume h2 : p ∣ 1\n show ∃ a ∈ [], p ∣ a from\n absurd (eq_one_of_dvd_one h2) (prime_not_one h1)\n done\n · -- Induction Step\n fix b : Nat\n fix L : List Nat\n assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a\n --Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a\n assume h2 : p ∣ prod (b :: L)\n rewrite [prod_cons] at h2\n have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2\n by_cases on h3\n · -- Case 1. h3 : p ∣ b\n apply Exists.intro b\n show b ∈ b :: L ∧ p ∣ b from\n And.intro (List.mem_cons_self b L) h3\n done\n · -- Case 2. h3 : p ∣ prod L\n obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3\n apply Exists.intro a\n show a ∈ b :: L ∧ p ∣ a from\n And.intro (List.mem_cons_of_mem b h4.left) h4.right\n done\n done\n done",
"proofType": "tactic",
"proofLengthLines": 29,
"proofLengthTokens": 898
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
| lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l | HTPI.prime_in_list | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 649,
"tokenPositionInFile": 19812,
"theoremPositionInFile": 64
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3\n define at h2\n have h5 : prime a := h2 a h4.left\n have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right\n disj_syll h6 (prime_not_one h1)\n rewrite [h6]\n show a ∈ l from h4.left\n done",
"proofType": "tactic",
"proofLengthLines": 8,
"proofLengthTokens": 256
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
| lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q | HTPI.first_le_first | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 660,
"tokenPositionInFile": 20179,
"theoremPositionInFile": 65
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n define at h1; define at h2\n have h4 : q ∣ prod (p :: l) := by\n define\n apply Exists.intro (prod m)\n rewrite [←prod_cons]\n show prod (p :: l) = prod (q :: m) from h3\n done\n have h5 : all_prime (q :: m) := h2.left\n rewrite [all_prime_cons] at h5\n have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4\n have h7 : nondec (p :: l) := h1.right\n rewrite [nondec_cons] at h7\n rewrite [List.mem_cons] at h6\n by_cases on h6\n · -- Case 1. h6 : q = p\n linarith\n done\n · -- Case 2. h6 : q ∈ l\n have h8 : ∀ m ∈ l, p ≤ m := h7.left\n show p ≤ q from h8 q h6\n done\n done",
"proofType": "tactic",
"proofLengthLines": 22,
"proofLengthTokens": 605
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
| lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l | HTPI.nondec_prime_list_tail | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 686,
"tokenPositionInFile": 20957,
"theoremPositionInFile": 66
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n define at h\n define\n rewrite [all_prime_cons, nondec_cons] at h\n show all_prime l ∧ nondec l from And.intro h.left.right h.right.right\n done",
"proofType": "tactic",
"proofLengthLines": 5,
"proofLengthTokens": 152
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
| lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 | HTPI.cons_prod_not_one | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 694,
"tokenPositionInFile": 21224,
"theoremPositionInFile": 67
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n define at h\n have h1 : all_prime (p :: l) := h.left\n rewrite [all_prime_cons] at h1\n rewrite [prod_cons]\n by_contra h2\n show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)\n done",
"proofType": "tactic",
"proofLengthLines": 7,
"proofLengthTokens": 203
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
| lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 | HTPI.list_nil_iff_prod_one | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 704,
"tokenPositionInFile": 21535,
"theoremPositionInFile": 68
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n apply Iff.intro\n · -- (→)\n assume h1 : l = []\n rewrite [h1]\n show prod [] = 1 from prod_nil\n done\n · -- (←)\n contrapos\n assume h1 : ¬l = []\n obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from\n List.exists_cons_of_ne_nil h1\n obtain (L : List Nat) (h3 : l = p :: L) from h2\n rewrite [h3] at h\n rewrite [h3]\n show ¬prod (p :: L) = 1 from cons_prod_not_one h\n done\n done",
"proofType": "tactic",
"proofLengthLines": 17,
"proofLengthTokens": 425
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
| lemma prime_pos {p : Nat} (h : prime p) : p > 0 | HTPI.prime_pos | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 724,
"tokenPositionInFile": 22057,
"theoremPositionInFile": 69
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n define at h\n linarith\n done",
"proofType": "tactic",
"proofLengthLines": 3,
"proofLengthTokens": 37
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
| theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 | HTPI.Theorem_7_2_5 | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 729,
"tokenPositionInFile": 22144,
"theoremPositionInFile": 70
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n apply List.rec\n · -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →\n -- nondec_prime_list l2 → prod [] = prod l2 → [] = l2\n fix l2 : List Nat\n assume h1 : nondec_prime_list []\n assume h2 : nondec_prime_list l2\n assume h3 : prod [] = prod l2\n rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3\n show [] = l2 from h3.symm\n done\n · -- Induction Step\n fix p : Nat\n fix L1 : List Nat\n assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →\n nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2\n -- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →\n -- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2\n fix l2 : List Nat\n assume h1 : nondec_prime_list (p :: L1)\n assume h2 : nondec_prime_list l2\n assume h3 : prod (p :: L1) = prod l2\n have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1\n rewrite [h3, ←list_nil_iff_prod_one h2] at h4\n obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from\n List.exists_cons_of_ne_nil h4\n obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5\n rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)\n rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)\n have h7 : p ≤ q := first_le_first h1 h2 h3\n have h8 : q ≤ p := first_le_first h2 h1 h3.symm\n have h9 : p = q := by linarith\n rewrite [h9, prod_cons, prod_cons] at h3\n --h3 : q * prod L1 = q * prod L2\n have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1\n have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2\n define at h2\n have h12 : all_prime (q :: L2) := h2.left\n rewrite [all_prime_cons] at h12\n have h13 : q > 0 := prime_pos h12.left\n have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3\n have h15 : L1 = L2 := ih L2 h10 h11 h14\n rewrite [h6, h9, h15]\n rfl\n done\n done",
"proofType": "tactic",
"proofLengthLines": 45,
"proofLengthTokens": 1875
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
| theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l | HTPI.fund_thm_arith | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 778,
"tokenPositionInFile": 24149,
"theoremPositionInFile": 71
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n exists_unique\n · -- Existence\n show ∃ (l : List Nat), prime_factorization n l from\n exists_prime_factorization n h\n done\n · -- Uniqueness\n fix l1 : List Nat; fix l2 : List Nat\n assume h1 : prime_factorization n l1\n assume h2 : prime_factorization n l2\n define at h1; define at h2\n have h3 : prod l1 = n := h1.right\n rewrite [←h2.right] at h3\n show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3\n done\n done",
"proofType": "tactic",
"proofLengthLines": 15,
"proofLengthTokens": 457
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
| theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) | HTPI.congr_refl | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 797,
"tokenPositionInFile": 24720,
"theoremPositionInFile": 72
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n fix a : Int\n define --Goal : ∃ (c : Int), a - a = ↑m * c\n apply Exists.intro 0\n ring\n done",
"proofType": "tactic",
"proofLengthLines": 5,
"proofLengthTokens": 117
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
| theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) | HTPI.congr_symm | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 804,
"tokenPositionInFile": 24897,
"theoremPositionInFile": 73
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n fix a : Int; fix b : Int\n assume h1 : a ≡ b (MOD m)\n define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c\n define --Goal : ∃ (c : Int), b - a = ↑m * c\n obtain (c : Int) (h2 : a - b = m * c) from h1\n apply Exists.intro (-c)\n show b - a = m * (-c) from\n calc b - a\n _ = -(a - b) := by ring\n _ = -(m * c) := by rw [h2]\n _ = m * (-c) := by ring\n done",
"proofType": "tactic",
"proofLengthLines": 12,
"proofLengthTokens": 412
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
| theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) | HTPI.congr_trans | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 819,
"tokenPositionInFile": 25391,
"theoremPositionInFile": 74
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": false,
"proof": ":= sorry",
"proofType": "term",
"proofLengthLines": 0,
"proofLengthTokens": 8
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
| lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val | HTPI.cc_eq_iff_val_eq | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 823,
"tokenPositionInFile": 25551,
"theoremPositionInFile": 75
} | {
"inFilePremises": false,
"repositoryPremises": false
} | {
"hasProof": true,
"proof": ":= Fin.ext_iff",
"proofType": "term",
"proofLengthLines": 0,
"proofLengthTokens": 14
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
| lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) | HTPI.val_nat_eq_mod | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 826,
"tokenPositionInFile": 25649,
"theoremPositionInFile": 76
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by rfl",
"proofType": "tactic",
"proofLengthLines": 0,
"proofLengthTokens": 9
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
| lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 | HTPI.val_zero | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 829,
"tokenPositionInFile": 25731,
"theoremPositionInFile": 77
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by rfl",
"proofType": "tactic",
"proofLengthLines": 0,
"proofLengthTokens": 9
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
| theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m | HTPI.cc_rep | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 831,
"tokenPositionInFile": 25791,
"theoremPositionInFile": 78
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":=\n match m with\n | 0 => by\n apply Exists.intro X\n rfl\n done\n | n + 1 => by\n apply Exists.intro ↑(X.val)\n have h1 : X.val < n + 1 := Fin.prop X\n rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]\n rfl\n done",
"proofType": "term",
"proofLengthLines": 11,
"proofLengthTokens": 266
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
| theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m | HTPI.add_class | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 844,
"tokenPositionInFile": 26122,
"theoremPositionInFile": 79
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= (Int.cast_add a b).symm",
"proofType": "term",
"proofLengthLines": 0,
"proofLengthTokens": 26
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
| theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m | HTPI.mul_class | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 847,
"tokenPositionInFile": 26222,
"theoremPositionInFile": 80
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= (Int.cast_mul a b).symm",
"proofType": "term",
"proofLengthLines": 0,
"proofLengthTokens": 26
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
| lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m | HTPI.cc_eq_iff_sub_zero | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 850,
"tokenPositionInFile": 26322,
"theoremPositionInFile": 81
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n apply Iff.intro\n · -- (→)\n assume h1 : [a]_m = [b]_m\n have h2 : a - b = a + (-b) := by ring\n have h3 : b + (-b) = 0 := by ring\n show [a - b]_m = [0]_m from\n calc [a - b]_m\n _ = [a + (-b)]_m := by rw [h2]\n _ = [a]_m + [-b]_m := by rw [add_class]\n _ = [b]_m + [-b]_m := by rw [h1]\n _ = [b + -b]_m := by rw [add_class]\n _ = [0]_m := by rw [h3]\n done\n · -- (←)\n assume h1 : [a - b]_m = [0]_m\n have h2 : b + (a - b) = a := by ring\n have h3 : b + 0 = b := by ring\n show [a]_m = [b]_m from\n calc [a]_m\n _ = [b + (a - b)]_m := by rw [h2]\n _ = [b]_m + [a - b]_m := by rw [add_class]\n _ = [b]_m + [0]_m := by rw [h1]\n _ = [b + 0]_m := by rw [add_class]\n _ = [b]_m := by rw [h3]\n done\n done",
"proofType": "tactic",
"proofLengthLines": 26,
"proofLengthTokens": 800
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
| lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m | HTPI.cc_neg_zero_of_cc_zero | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 879,
"tokenPositionInFile": 27211,
"theoremPositionInFile": 82
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n assume h1 : [a]_m = [0]_m\n have h2 : 0 + (-a) = -a := by ring\n have h3 : a + (-a) = 0 := by ring\n show [-a]_m = [0]_m from\n calc [-a]_m\n _ = [0 + (-a)]_m := by rw [h2]\n _ = [0]_m + [-a]_m := by rw [add_class]\n _ = [a]_m + [-a]_m := by rw [h1]\n _ = [a + (-a)]_m := by rw [add_class]\n _ = [0]_m := by rw [h3]\n done",
"proofType": "tactic",
"proofLengthLines": 11,
"proofLengthTokens": 352
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
| lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m | HTPI.cc_neg_zero_iff_cc_zero | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 893,
"tokenPositionInFile": 27651,
"theoremPositionInFile": 83
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)\n assume h1 : [-a]_m = [0]_m\n have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1\n have h3 : -(-a) = a := by ring\n rewrite [h3] at h2\n show [a]_m = [0]_m from h2\n done",
"proofType": "tactic",
"proofLengthLines": 7,
"proofLengthTokens": 239
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
| lemma cc_mod_0 (a : Int) : [a]_0 = a | HTPI.cc_mod_0 | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 903,
"tokenPositionInFile": 27979,
"theoremPositionInFile": 84
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by rfl",
"proofType": "tactic",
"proofLengthLines": 0,
"proofLengthTokens": 9
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
| lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k | HTPI.cc_nat_zero_iff_dvd | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 905,
"tokenPositionInFile": 28027,
"theoremPositionInFile": 85
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":=\n match m with\n | 0 => by\n have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl\n rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]\n apply Iff.intro\n · -- (→)\n assume h1 : k = 0\n rewrite [h1]\n show 0 ∣ 0 from dvd_self 0\n done\n · -- (←)\n assume h1 : 0 ∣ k\n obtain (c : Nat) (h2 : k = 0 * c) from h1\n rewrite [h2]\n ring\n done\n done\n | n + 1 => by\n rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]\n show k % (n + 1) = 0 ↔ n + 1 ∣ k from\n (Nat.dvd_iff_mod_eq_zero (n + 1) k).symm\n done",
"proofType": "term",
"proofLengthLines": 22,
"proofLengthTokens": 601
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
| lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a | HTPI.cc_zero_iff_dvd | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 929,
"tokenPositionInFile": 28692,
"theoremPositionInFile": 86
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a\n by_cases on h1\n · -- Case 1. h1: a = ↑k\n rewrite [h1, Int.natCast_dvd_natCast]\n show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k\n done\n · -- Case 2. h1: a = -↑k\n rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]\n show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k\n done\n done",
"proofType": "tactic",
"proofLengthLines": 11,
"proofLengthTokens": 412
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
| theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) | HTPI.cc_eq_iff_congr | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 942,
"tokenPositionInFile": 29173,
"theoremPositionInFile": 87
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":=\n calc [a]_m = [b]_m\n _ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b\n _ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)\n _ ↔ a ≡ b (MOD m) := by rfl",
"proofType": "term",
"proofLengthLines": 4,
"proofLengthTokens": 159
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
| lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m | HTPI.mod_nonneg | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 950,
"tokenPositionInFile": 29474,
"theoremPositionInFile": 88
} | {
"inFilePremises": false,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)\n show 0 ≤ a % m from Int.emod_nonneg a h1\n done",
"proofType": "tactic",
"proofLengthLines": 3,
"proofLengthTokens": 122
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
| lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m | HTPI.mod_lt | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 955,
"tokenPositionInFile": 29658,
"theoremPositionInFile": 89
} | {
"inFilePremises": false,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)\n have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1\n show a % m < m from Int.emod_lt_of_pos a h2\n done",
"proofType": "tactic",
"proofLengthLines": 4,
"proofLengthTokens": 164
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
| lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) | HTPI.congr_mod_mod | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 961,
"tokenPositionInFile": 29880,
"theoremPositionInFile": 90
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n define\n have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m\n apply Exists.intro (a / m)\n show a - a % m = m * (a / m) from\n calc a - (a % m)\n _ = m * (a / m) + a % m - a % m := by rw [h1]\n _ = m * (a / m) := by ring\n done",
"proofType": "tactic",
"proofLengthLines": 8,
"proofLengthTokens": 253
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
| lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) | HTPI.mod_cmpl_res | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 971,
"tokenPositionInFile": 30195,
"theoremPositionInFile": 91
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":=\n And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))",
"proofType": "term",
"proofLengthLines": 1,
"proofLengthTokens": 76
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
| theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) | HTPI.Theorem_7_3_1 | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 975,
"tokenPositionInFile": 30371,
"theoremPositionInFile": 92
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n exists_unique\n · -- Existence\n apply Exists.intro (a % m)\n show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from\n mod_cmpl_res m a\n done\n · -- Uniqueness\n fix r1 : Int; fix r2 : Int\n assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)\n assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)\n have h3 : r1 ≡ r2 (MOD m) :=\n congr_trans (congr_symm h1.right.right) h2.right.right\n obtain (d : Int) (h4 : r1 - r2 = m * d) from h3\n have h5 : r1 - r2 < m * 1 := by linarith\n have h6 : m * (-1) < r1 - r2 := by linarith\n rewrite [h4] at h5 --h5 : m * d < m * 1\n rewrite [h4] at h6 --h6 : m * -1 < m * d\n have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m\n have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7\n have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7\n have h10 : d = 0 := by linarith\n show r1 = r2 from\n calc r1\n _ = r1 - r2 + r2 := by ring\n _ = m * 0 + r2 := by rw [h4, h10]\n _ = r2 := by ring\n done\n done",
"proofType": "tactic",
"proofLengthLines": 28,
"proofLengthTokens": 1001
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
| lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m | HTPI.cc_eq_mod | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1006,
"tokenPositionInFile": 31477,
"theoremPositionInFile": 93
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":=\n (cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)",
"proofType": "term",
"proofLengthLines": 1,
"proofLengthTokens": 58
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
| theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X | HTPI.Theorem_7_3_6_1 | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1009,
"tokenPositionInFile": 31593,
"theoremPositionInFile": 94
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n obtain (a : Int) (h1 : X = [a]_m) from cc_rep X\n obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y\n rewrite [h1, h2]\n have h3 : a + b = b + a := by ring\n show [a]_m + [b]_m = [b]_m + [a]_m from\n calc [a]_m + [b]_m\n _ = [a + b]_m := add_class m a b\n _ = [b + a]_m := by rw [h3]\n _ = [b]_m + [a]_m := (add_class m b a).symm\n done",
"proofType": "tactic",
"proofLengthLines": 10,
"proofLengthTokens": 356
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
| theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X | HTPI.Theorem_7_3_6_7 | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1021,
"tokenPositionInFile": 32016,
"theoremPositionInFile": 95
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n obtain (a : Int) (h1 : X = [a]_m) from cc_rep X\n rewrite [h1]\n have h2 : a * 1 = a := by ring\n show [a]_m * [1]_m = [a]_m from\n calc [a]_m * [1]_m\n _ = [a * 1]_m := mul_class m a 1\n _ = [a]_m := by rw [h2]\n done",
"proofType": "tactic",
"proofLengthLines": 8,
"proofLengthTokens": 236
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
| theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 | HTPI.Exercise_7_2_6 | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1031,
"tokenPositionInFile": 32317,
"theoremPositionInFile": 96
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": false,
"proof": ":= sorry",
"proofType": "term",
"proofLengthLines": 0,
"proofLengthTokens": 8
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
| lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m | HTPI.gcd_c2_inv | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1034,
"tokenPositionInFile": 32417,
"theoremPositionInFile": 97
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n set s : Int := gcd_c1 m a\n have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m\n define at h1\n rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1\n rewrite [mul_class, cc_eq_iff_congr]\n define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c\n apply Exists.intro (-s)\n show a * (gcd_c2 m a) - 1 = m * (-s) from\n calc a * (gcd_c2 m a) - 1\n _ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring\n _ = 1 + m * (-s) - 1 := by rw [h2]\n _ = m * (-s) := by ring\n done",
"proofType": "tactic",
"proofLengthLines": 13,
"proofLengthTokens": 529
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
| theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a | HTPI.Theorem_7_3_7 | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1050,
"tokenPositionInFile": 33035,
"theoremPositionInFile": 98
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n apply Iff.intro\n · -- (→)\n assume h1 : invertible [a]_m\n define at h1\n obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1\n obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y\n rewrite [h3, mul_class, cc_eq_iff_congr] at h2\n define at h2\n obtain (c : Int) (h4 : a * b - 1 = m * c) from h2\n rewrite [Exercise_7_2_6]\n --Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1\n apply Exists.intro (-c)\n apply Exists.intro b\n show (-c) * m + b * a = 1 from\n calc (-c) * m + b * a\n _ = (-c) * m + (a * b - 1) + 1 := by ring\n _ = (-c) * m + m * c + 1 := by rw [h4]\n _ = 1 := by ring\n done\n · -- (←)\n assume h1 : rel_prime m a\n define\n show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from\n Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)\n done\n done",
"proofType": "tactic",
"proofLengthLines": 26,
"proofLengthTokens": 807
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
| lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 | HTPI.num_rp_below_base | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1083,
"tokenPositionInFile": 33961,
"theoremPositionInFile": 99
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by rfl",
"proofType": "tactic",
"proofLengthLines": 0,
"proofLengthTokens": 9
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 := by rfl
| lemma num_rp_below_step_rp {m j : Nat} (h : rel_prime m j) :
num_rp_below m (j + 1) = (num_rp_below m j) + 1 | HTPI.num_rp_below_step_rp | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1086,
"tokenPositionInFile": 34033,
"theoremPositionInFile": 100
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n have h1 : num_rp_below m (j + 1) =\n if gcd m j = 1 then (num_rp_below m j) + 1\n else num_rp_below m j := by rfl\n define at h --h : gcd m j = 1\n rewrite [if_pos h] at h1\n --h1 : num_rp_below m (j + 1) = num_rp_below m j + 1\n show num_rp_below m (j + 1) = num_rp_below m j + 1 from h1\n done",
"proofType": "tactic",
"proofLengthLines": 8,
"proofLengthTokens": 327
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 := by rfl
lemma num_rp_below_step_rp {m j : Nat} (h : rel_prime m j) :
num_rp_below m (j + 1) = (num_rp_below m j) + 1 := by
have h1 : num_rp_below m (j + 1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : gcd m j = 1
rewrite [if_pos h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j + 1
show num_rp_below m (j + 1) = num_rp_below m j + 1 from h1
done
| lemma num_rp_below_step_not_rp {m j : Nat} (h : ¬rel_prime m j) :
num_rp_below m (j + 1) = num_rp_below m j | HTPI.num_rp_below_step_not_rp | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1097,
"tokenPositionInFile": 34475,
"theoremPositionInFile": 101
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n have h1 : num_rp_below m (j +1) =\n if gcd m j = 1 then (num_rp_below m j) + 1\n else num_rp_below m j := by rfl\n define at h --h : ¬gcd m j = 1\n rewrite [if_neg h] at h1\n --h1 : num_rp_below m (j + 1) = num_rp_below m j\n show num_rp_below m (j + 1) = num_rp_below m j from h1\n done",
"proofType": "tactic",
"proofLengthLines": 8,
"proofLengthTokens": 319
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 := by rfl
lemma num_rp_below_step_rp {m j : Nat} (h : rel_prime m j) :
num_rp_below m (j + 1) = (num_rp_below m j) + 1 := by
have h1 : num_rp_below m (j + 1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : gcd m j = 1
rewrite [if_pos h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j + 1
show num_rp_below m (j + 1) = num_rp_below m j + 1 from h1
done
lemma num_rp_below_step_not_rp {m j : Nat} (h : ¬rel_prime m j) :
num_rp_below m (j + 1) = num_rp_below m j := by
have h1 : num_rp_below m (j +1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : ¬gcd m j = 1
rewrite [if_neg h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j
show num_rp_below m (j + 1) = num_rp_below m j from h1
done
| lemma phi_def (m : Nat) : phi m = num_rp_below m m | HTPI.phi_def | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1108,
"tokenPositionInFile": 34908,
"theoremPositionInFile": 102
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by rfl",
"proofType": "tactic",
"proofLengthLines": 0,
"proofLengthTokens": 9
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 := by rfl
lemma num_rp_below_step_rp {m j : Nat} (h : rel_prime m j) :
num_rp_below m (j + 1) = (num_rp_below m j) + 1 := by
have h1 : num_rp_below m (j + 1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : gcd m j = 1
rewrite [if_pos h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j + 1
show num_rp_below m (j + 1) = num_rp_below m j + 1 from h1
done
lemma num_rp_below_step_not_rp {m j : Nat} (h : ¬rel_prime m j) :
num_rp_below m (j + 1) = num_rp_below m j := by
have h1 : num_rp_below m (j +1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : ¬gcd m j = 1
rewrite [if_neg h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j
show num_rp_below m (j + 1) = num_rp_below m j from h1
done
lemma phi_def (m : Nat) : phi m = num_rp_below m m := by rfl
#eval phi 10 --Answer: 4
| lemma prod_inv_iff_inv {m : Nat} {X : ZMod m}
(h1 : invertible X) (Y : ZMod m) :
invertible (X * Y) ↔ invertible Y | HTPI.prod_inv_iff_inv | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1112,
"tokenPositionInFile": 34999,
"theoremPositionInFile": 103
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n apply Iff.intro\n · -- (→)\n assume h2 : invertible (X * Y)\n obtain (Z : ZMod m) (h3 : X * Y * Z = [1]_m) from h2\n apply Exists.intro (X * Z)\n rewrite [←h3] --Goal : Y * (X * Z) = X * Y * Z\n ring --Note that ring can do algebra in ZMod m\n done\n · -- (←)\n assume h2 : invertible Y\n obtain (Xi : ZMod m) (h3 : X * Xi = [1]_m) from h1\n obtain (Yi : ZMod m) (h4 : Y * Yi = [1]_m) from h2\n apply Exists.intro (Xi * Yi)\n show (X * Y) * (Xi * Yi) = [1]_m from\n calc X * Y * (Xi * Yi)\n _ = (X * Xi) * (Y * Yi) := by ring\n _ = [1]_m * [1]_m := by rw [h3, h4]\n _ = [1]_m := Theorem_7_3_6_7 [1]_m\n done\n done",
"proofType": "tactic",
"proofLengthLines": 20,
"proofLengthTokens": 673
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 := by rfl
lemma num_rp_below_step_rp {m j : Nat} (h : rel_prime m j) :
num_rp_below m (j + 1) = (num_rp_below m j) + 1 := by
have h1 : num_rp_below m (j + 1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : gcd m j = 1
rewrite [if_pos h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j + 1
show num_rp_below m (j + 1) = num_rp_below m j + 1 from h1
done
lemma num_rp_below_step_not_rp {m j : Nat} (h : ¬rel_prime m j) :
num_rp_below m (j + 1) = num_rp_below m j := by
have h1 : num_rp_below m (j +1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : ¬gcd m j = 1
rewrite [if_neg h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j
show num_rp_below m (j + 1) = num_rp_below m j from h1
done
lemma phi_def (m : Nat) : phi m = num_rp_below m m := by rfl
#eval phi 10 --Answer: 4
lemma prod_inv_iff_inv {m : Nat} {X : ZMod m}
(h1 : invertible X) (Y : ZMod m) :
invertible (X * Y) ↔ invertible Y := by
apply Iff.intro
· -- (→)
assume h2 : invertible (X * Y)
obtain (Z : ZMod m) (h3 : X * Y * Z = [1]_m) from h2
apply Exists.intro (X * Z)
rewrite [←h3] --Goal : Y * (X * Z) = X * Y * Z
ring --Note that ring can do algebra in ZMod m
done
· -- (←)
assume h2 : invertible Y
obtain (Xi : ZMod m) (h3 : X * Xi = [1]_m) from h1
obtain (Yi : ZMod m) (h4 : Y * Yi = [1]_m) from h2
apply Exists.intro (Xi * Yi)
show (X * Y) * (Xi * Yi) = [1]_m from
calc X * Y * (Xi * Yi)
_ = (X * Xi) * (Y * Yi) := by ring
_ = [1]_m * [1]_m := by rw [h3, h4]
_ = [1]_m := Theorem_7_3_6_7 [1]_m
done
done
| lemma F_rp_def {m i : Nat} (h : rel_prime m i) :
F m i = [i]_m | HTPI.F_rp_def | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1136,
"tokenPositionInFile": 35797,
"theoremPositionInFile": 104
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl\n define at h --h : gcd m i = 1\n rewrite [if_pos h] at h1\n show F m i = [i]_m from h1\n done",
"proofType": "tactic",
"proofLengthLines": 5,
"proofLengthTokens": 172
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 := by rfl
lemma num_rp_below_step_rp {m j : Nat} (h : rel_prime m j) :
num_rp_below m (j + 1) = (num_rp_below m j) + 1 := by
have h1 : num_rp_below m (j + 1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : gcd m j = 1
rewrite [if_pos h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j + 1
show num_rp_below m (j + 1) = num_rp_below m j + 1 from h1
done
lemma num_rp_below_step_not_rp {m j : Nat} (h : ¬rel_prime m j) :
num_rp_below m (j + 1) = num_rp_below m j := by
have h1 : num_rp_below m (j +1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : ¬gcd m j = 1
rewrite [if_neg h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j
show num_rp_below m (j + 1) = num_rp_below m j from h1
done
lemma phi_def (m : Nat) : phi m = num_rp_below m m := by rfl
#eval phi 10 --Answer: 4
lemma prod_inv_iff_inv {m : Nat} {X : ZMod m}
(h1 : invertible X) (Y : ZMod m) :
invertible (X * Y) ↔ invertible Y := by
apply Iff.intro
· -- (→)
assume h2 : invertible (X * Y)
obtain (Z : ZMod m) (h3 : X * Y * Z = [1]_m) from h2
apply Exists.intro (X * Z)
rewrite [←h3] --Goal : Y * (X * Z) = X * Y * Z
ring --Note that ring can do algebra in ZMod m
done
· -- (←)
assume h2 : invertible Y
obtain (Xi : ZMod m) (h3 : X * Xi = [1]_m) from h1
obtain (Yi : ZMod m) (h4 : Y * Yi = [1]_m) from h2
apply Exists.intro (Xi * Yi)
show (X * Y) * (Xi * Yi) = [1]_m from
calc X * Y * (Xi * Yi)
_ = (X * Xi) * (Y * Yi) := by ring
_ = [1]_m * [1]_m := by rw [h3, h4]
_ = [1]_m := Theorem_7_3_6_7 [1]_m
done
done
lemma F_rp_def {m i : Nat} (h : rel_prime m i) :
F m i = [i]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h --h : gcd m i = 1
rewrite [if_pos h] at h1
show F m i = [i]_m from h1
done
| lemma F_not_rp_def {m i : Nat} (h : ¬rel_prime m i) :
F m i = [1]_m | HTPI.F_not_rp_def | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1144,
"tokenPositionInFile": 36038,
"theoremPositionInFile": 105
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl\n define at h\n rewrite [h1, if_neg h]\n rfl\n done",
"proofType": "tactic",
"proofLengthLines": 5,
"proofLengthTokens": 124
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 := by rfl
lemma num_rp_below_step_rp {m j : Nat} (h : rel_prime m j) :
num_rp_below m (j + 1) = (num_rp_below m j) + 1 := by
have h1 : num_rp_below m (j + 1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : gcd m j = 1
rewrite [if_pos h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j + 1
show num_rp_below m (j + 1) = num_rp_below m j + 1 from h1
done
lemma num_rp_below_step_not_rp {m j : Nat} (h : ¬rel_prime m j) :
num_rp_below m (j + 1) = num_rp_below m j := by
have h1 : num_rp_below m (j +1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : ¬gcd m j = 1
rewrite [if_neg h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j
show num_rp_below m (j + 1) = num_rp_below m j from h1
done
lemma phi_def (m : Nat) : phi m = num_rp_below m m := by rfl
#eval phi 10 --Answer: 4
lemma prod_inv_iff_inv {m : Nat} {X : ZMod m}
(h1 : invertible X) (Y : ZMod m) :
invertible (X * Y) ↔ invertible Y := by
apply Iff.intro
· -- (→)
assume h2 : invertible (X * Y)
obtain (Z : ZMod m) (h3 : X * Y * Z = [1]_m) from h2
apply Exists.intro (X * Z)
rewrite [←h3] --Goal : Y * (X * Z) = X * Y * Z
ring --Note that ring can do algebra in ZMod m
done
· -- (←)
assume h2 : invertible Y
obtain (Xi : ZMod m) (h3 : X * Xi = [1]_m) from h1
obtain (Yi : ZMod m) (h4 : Y * Yi = [1]_m) from h2
apply Exists.intro (Xi * Yi)
show (X * Y) * (Xi * Yi) = [1]_m from
calc X * Y * (Xi * Yi)
_ = (X * Xi) * (Y * Yi) := by ring
_ = [1]_m * [1]_m := by rw [h3, h4]
_ = [1]_m := Theorem_7_3_6_7 [1]_m
done
done
lemma F_rp_def {m i : Nat} (h : rel_prime m i) :
F m i = [i]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h --h : gcd m i = 1
rewrite [if_pos h] at h1
show F m i = [i]_m from h1
done
lemma F_not_rp_def {m i : Nat} (h : ¬rel_prime m i) :
F m i = [1]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h
rewrite [h1, if_neg h]
rfl
done
| lemma prod_seq_base {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 0 k f = [1]_m | HTPI.prod_seq_base | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1152,
"tokenPositionInFile": 36236,
"theoremPositionInFile": 106
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by rfl",
"proofType": "tactic",
"proofLengthLines": 0,
"proofLengthTokens": 9
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 := by rfl
lemma num_rp_below_step_rp {m j : Nat} (h : rel_prime m j) :
num_rp_below m (j + 1) = (num_rp_below m j) + 1 := by
have h1 : num_rp_below m (j + 1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : gcd m j = 1
rewrite [if_pos h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j + 1
show num_rp_below m (j + 1) = num_rp_below m j + 1 from h1
done
lemma num_rp_below_step_not_rp {m j : Nat} (h : ¬rel_prime m j) :
num_rp_below m (j + 1) = num_rp_below m j := by
have h1 : num_rp_below m (j +1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : ¬gcd m j = 1
rewrite [if_neg h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j
show num_rp_below m (j + 1) = num_rp_below m j from h1
done
lemma phi_def (m : Nat) : phi m = num_rp_below m m := by rfl
#eval phi 10 --Answer: 4
lemma prod_inv_iff_inv {m : Nat} {X : ZMod m}
(h1 : invertible X) (Y : ZMod m) :
invertible (X * Y) ↔ invertible Y := by
apply Iff.intro
· -- (→)
assume h2 : invertible (X * Y)
obtain (Z : ZMod m) (h3 : X * Y * Z = [1]_m) from h2
apply Exists.intro (X * Z)
rewrite [←h3] --Goal : Y * (X * Z) = X * Y * Z
ring --Note that ring can do algebra in ZMod m
done
· -- (←)
assume h2 : invertible Y
obtain (Xi : ZMod m) (h3 : X * Xi = [1]_m) from h1
obtain (Yi : ZMod m) (h4 : Y * Yi = [1]_m) from h2
apply Exists.intro (Xi * Yi)
show (X * Y) * (Xi * Yi) = [1]_m from
calc X * Y * (Xi * Yi)
_ = (X * Xi) * (Y * Yi) := by ring
_ = [1]_m * [1]_m := by rw [h3, h4]
_ = [1]_m := Theorem_7_3_6_7 [1]_m
done
done
lemma F_rp_def {m i : Nat} (h : rel_prime m i) :
F m i = [i]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h --h : gcd m i = 1
rewrite [if_pos h] at h1
show F m i = [i]_m from h1
done
lemma F_not_rp_def {m i : Nat} (h : ¬rel_prime m i) :
F m i = [1]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h
rewrite [h1, if_neg h]
rfl
done
lemma prod_seq_base {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 0 k f = [1]_m := by rfl
| lemma prod_seq_step {m : Nat}
(n k : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) k f = prod_seq n k f * f (k + n) | HTPI.prod_seq_step | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1155,
"tokenPositionInFile": 36335,
"theoremPositionInFile": 107
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by rfl",
"proofType": "tactic",
"proofLengthLines": 0,
"proofLengthTokens": 9
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 := by rfl
lemma num_rp_below_step_rp {m j : Nat} (h : rel_prime m j) :
num_rp_below m (j + 1) = (num_rp_below m j) + 1 := by
have h1 : num_rp_below m (j + 1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : gcd m j = 1
rewrite [if_pos h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j + 1
show num_rp_below m (j + 1) = num_rp_below m j + 1 from h1
done
lemma num_rp_below_step_not_rp {m j : Nat} (h : ¬rel_prime m j) :
num_rp_below m (j + 1) = num_rp_below m j := by
have h1 : num_rp_below m (j +1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : ¬gcd m j = 1
rewrite [if_neg h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j
show num_rp_below m (j + 1) = num_rp_below m j from h1
done
lemma phi_def (m : Nat) : phi m = num_rp_below m m := by rfl
#eval phi 10 --Answer: 4
lemma prod_inv_iff_inv {m : Nat} {X : ZMod m}
(h1 : invertible X) (Y : ZMod m) :
invertible (X * Y) ↔ invertible Y := by
apply Iff.intro
· -- (→)
assume h2 : invertible (X * Y)
obtain (Z : ZMod m) (h3 : X * Y * Z = [1]_m) from h2
apply Exists.intro (X * Z)
rewrite [←h3] --Goal : Y * (X * Z) = X * Y * Z
ring --Note that ring can do algebra in ZMod m
done
· -- (←)
assume h2 : invertible Y
obtain (Xi : ZMod m) (h3 : X * Xi = [1]_m) from h1
obtain (Yi : ZMod m) (h4 : Y * Yi = [1]_m) from h2
apply Exists.intro (Xi * Yi)
show (X * Y) * (Xi * Yi) = [1]_m from
calc X * Y * (Xi * Yi)
_ = (X * Xi) * (Y * Yi) := by ring
_ = [1]_m * [1]_m := by rw [h3, h4]
_ = [1]_m := Theorem_7_3_6_7 [1]_m
done
done
lemma F_rp_def {m i : Nat} (h : rel_prime m i) :
F m i = [i]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h --h : gcd m i = 1
rewrite [if_pos h] at h1
show F m i = [i]_m from h1
done
lemma F_not_rp_def {m i : Nat} (h : ¬rel_prime m i) :
F m i = [1]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h
rewrite [h1, if_neg h]
rfl
done
lemma prod_seq_base {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 0 k f = [1]_m := by rfl
lemma prod_seq_step {m : Nat}
(n k : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) k f = prod_seq n k f * f (k + n) := by rfl
| lemma prod_seq_zero_step {m : Nat}
(n : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) 0 f = prod_seq n 0 f * f n | HTPI.prod_seq_zero_step | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1159,
"tokenPositionInFile": 36467,
"theoremPositionInFile": 108
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n rewrite [prod_seq_step, zero_add]\n rfl\n done",
"proofType": "tactic",
"proofLengthLines": 3,
"proofLengthTokens": 54
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 := by rfl
lemma num_rp_below_step_rp {m j : Nat} (h : rel_prime m j) :
num_rp_below m (j + 1) = (num_rp_below m j) + 1 := by
have h1 : num_rp_below m (j + 1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : gcd m j = 1
rewrite [if_pos h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j + 1
show num_rp_below m (j + 1) = num_rp_below m j + 1 from h1
done
lemma num_rp_below_step_not_rp {m j : Nat} (h : ¬rel_prime m j) :
num_rp_below m (j + 1) = num_rp_below m j := by
have h1 : num_rp_below m (j +1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : ¬gcd m j = 1
rewrite [if_neg h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j
show num_rp_below m (j + 1) = num_rp_below m j from h1
done
lemma phi_def (m : Nat) : phi m = num_rp_below m m := by rfl
#eval phi 10 --Answer: 4
lemma prod_inv_iff_inv {m : Nat} {X : ZMod m}
(h1 : invertible X) (Y : ZMod m) :
invertible (X * Y) ↔ invertible Y := by
apply Iff.intro
· -- (→)
assume h2 : invertible (X * Y)
obtain (Z : ZMod m) (h3 : X * Y * Z = [1]_m) from h2
apply Exists.intro (X * Z)
rewrite [←h3] --Goal : Y * (X * Z) = X * Y * Z
ring --Note that ring can do algebra in ZMod m
done
· -- (←)
assume h2 : invertible Y
obtain (Xi : ZMod m) (h3 : X * Xi = [1]_m) from h1
obtain (Yi : ZMod m) (h4 : Y * Yi = [1]_m) from h2
apply Exists.intro (Xi * Yi)
show (X * Y) * (Xi * Yi) = [1]_m from
calc X * Y * (Xi * Yi)
_ = (X * Xi) * (Y * Yi) := by ring
_ = [1]_m * [1]_m := by rw [h3, h4]
_ = [1]_m := Theorem_7_3_6_7 [1]_m
done
done
lemma F_rp_def {m i : Nat} (h : rel_prime m i) :
F m i = [i]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h --h : gcd m i = 1
rewrite [if_pos h] at h1
show F m i = [i]_m from h1
done
lemma F_not_rp_def {m i : Nat} (h : ¬rel_prime m i) :
F m i = [1]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h
rewrite [h1, if_neg h]
rfl
done
lemma prod_seq_base {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 0 k f = [1]_m := by rfl
lemma prod_seq_step {m : Nat}
(n k : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) k f = prod_seq n k f * f (k + n) := by rfl
lemma prod_seq_zero_step {m : Nat}
(n : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) 0 f = prod_seq n 0 f * f n := by
rewrite [prod_seq_step, zero_add]
rfl
done
| lemma prod_one {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 1 k f = f k | HTPI.prod_one | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1166,
"tokenPositionInFile": 36641,
"theoremPositionInFile": 109
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n rewrite [prod_seq_step, prod_seq_base, add_zero, mul_comm, Theorem_7_3_6_7]\n rfl\n done",
"proofType": "tactic",
"proofLengthLines": 3,
"proofLengthTokens": 96
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 := by rfl
lemma num_rp_below_step_rp {m j : Nat} (h : rel_prime m j) :
num_rp_below m (j + 1) = (num_rp_below m j) + 1 := by
have h1 : num_rp_below m (j + 1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : gcd m j = 1
rewrite [if_pos h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j + 1
show num_rp_below m (j + 1) = num_rp_below m j + 1 from h1
done
lemma num_rp_below_step_not_rp {m j : Nat} (h : ¬rel_prime m j) :
num_rp_below m (j + 1) = num_rp_below m j := by
have h1 : num_rp_below m (j +1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : ¬gcd m j = 1
rewrite [if_neg h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j
show num_rp_below m (j + 1) = num_rp_below m j from h1
done
lemma phi_def (m : Nat) : phi m = num_rp_below m m := by rfl
#eval phi 10 --Answer: 4
lemma prod_inv_iff_inv {m : Nat} {X : ZMod m}
(h1 : invertible X) (Y : ZMod m) :
invertible (X * Y) ↔ invertible Y := by
apply Iff.intro
· -- (→)
assume h2 : invertible (X * Y)
obtain (Z : ZMod m) (h3 : X * Y * Z = [1]_m) from h2
apply Exists.intro (X * Z)
rewrite [←h3] --Goal : Y * (X * Z) = X * Y * Z
ring --Note that ring can do algebra in ZMod m
done
· -- (←)
assume h2 : invertible Y
obtain (Xi : ZMod m) (h3 : X * Xi = [1]_m) from h1
obtain (Yi : ZMod m) (h4 : Y * Yi = [1]_m) from h2
apply Exists.intro (Xi * Yi)
show (X * Y) * (Xi * Yi) = [1]_m from
calc X * Y * (Xi * Yi)
_ = (X * Xi) * (Y * Yi) := by ring
_ = [1]_m * [1]_m := by rw [h3, h4]
_ = [1]_m := Theorem_7_3_6_7 [1]_m
done
done
lemma F_rp_def {m i : Nat} (h : rel_prime m i) :
F m i = [i]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h --h : gcd m i = 1
rewrite [if_pos h] at h1
show F m i = [i]_m from h1
done
lemma F_not_rp_def {m i : Nat} (h : ¬rel_prime m i) :
F m i = [1]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h
rewrite [h1, if_neg h]
rfl
done
lemma prod_seq_base {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 0 k f = [1]_m := by rfl
lemma prod_seq_step {m : Nat}
(n k : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) k f = prod_seq n k f * f (k + n) := by rfl
lemma prod_seq_zero_step {m : Nat}
(n : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) 0 f = prod_seq n 0 f * f n := by
rewrite [prod_seq_step, zero_add]
rfl
done
lemma prod_one {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 1 k f = f k := by
rewrite [prod_seq_step, prod_seq_base, add_zero, mul_comm, Theorem_7_3_6_7]
rfl
done
| lemma G_def (m a i : Nat) : G m a i = (a * i) % m | HTPI.G_def | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1172,
"tokenPositionInFile": 36820,
"theoremPositionInFile": 110
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by rfl",
"proofType": "tactic",
"proofLengthLines": 0,
"proofLengthTokens": 9
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 := by rfl
lemma num_rp_below_step_rp {m j : Nat} (h : rel_prime m j) :
num_rp_below m (j + 1) = (num_rp_below m j) + 1 := by
have h1 : num_rp_below m (j + 1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : gcd m j = 1
rewrite [if_pos h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j + 1
show num_rp_below m (j + 1) = num_rp_below m j + 1 from h1
done
lemma num_rp_below_step_not_rp {m j : Nat} (h : ¬rel_prime m j) :
num_rp_below m (j + 1) = num_rp_below m j := by
have h1 : num_rp_below m (j +1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : ¬gcd m j = 1
rewrite [if_neg h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j
show num_rp_below m (j + 1) = num_rp_below m j from h1
done
lemma phi_def (m : Nat) : phi m = num_rp_below m m := by rfl
#eval phi 10 --Answer: 4
lemma prod_inv_iff_inv {m : Nat} {X : ZMod m}
(h1 : invertible X) (Y : ZMod m) :
invertible (X * Y) ↔ invertible Y := by
apply Iff.intro
· -- (→)
assume h2 : invertible (X * Y)
obtain (Z : ZMod m) (h3 : X * Y * Z = [1]_m) from h2
apply Exists.intro (X * Z)
rewrite [←h3] --Goal : Y * (X * Z) = X * Y * Z
ring --Note that ring can do algebra in ZMod m
done
· -- (←)
assume h2 : invertible Y
obtain (Xi : ZMod m) (h3 : X * Xi = [1]_m) from h1
obtain (Yi : ZMod m) (h4 : Y * Yi = [1]_m) from h2
apply Exists.intro (Xi * Yi)
show (X * Y) * (Xi * Yi) = [1]_m from
calc X * Y * (Xi * Yi)
_ = (X * Xi) * (Y * Yi) := by ring
_ = [1]_m * [1]_m := by rw [h3, h4]
_ = [1]_m := Theorem_7_3_6_7 [1]_m
done
done
lemma F_rp_def {m i : Nat} (h : rel_prime m i) :
F m i = [i]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h --h : gcd m i = 1
rewrite [if_pos h] at h1
show F m i = [i]_m from h1
done
lemma F_not_rp_def {m i : Nat} (h : ¬rel_prime m i) :
F m i = [1]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h
rewrite [h1, if_neg h]
rfl
done
lemma prod_seq_base {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 0 k f = [1]_m := by rfl
lemma prod_seq_step {m : Nat}
(n k : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) k f = prod_seq n k f * f (k + n) := by rfl
lemma prod_seq_zero_step {m : Nat}
(n : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) 0 f = prod_seq n 0 f * f n := by
rewrite [prod_seq_step, zero_add]
rfl
done
lemma prod_one {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 1 k f = f k := by
rewrite [prod_seq_step, prod_seq_base, add_zero, mul_comm, Theorem_7_3_6_7]
rfl
done
lemma G_def (m a i : Nat) : G m a i = (a * i) % m := by rfl
| lemma cc_G (m a i : Nat) : [G m a i]_m = [a]_m * [i]_m | HTPI.cc_G | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1174,
"tokenPositionInFile": 36881,
"theoremPositionInFile": 111
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":=\n calc [G m a i]_m\n _ = [(a * i) % m]_m := by rfl\n _ = [a * i]_m := (cc_eq_mod m (a * i)).symm\n _ = [a]_m * [i]_m := (mul_class m a i).symm",
"proofType": "term",
"proofLengthLines": 4,
"proofLengthTokens": 151
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 := by rfl
lemma num_rp_below_step_rp {m j : Nat} (h : rel_prime m j) :
num_rp_below m (j + 1) = (num_rp_below m j) + 1 := by
have h1 : num_rp_below m (j + 1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : gcd m j = 1
rewrite [if_pos h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j + 1
show num_rp_below m (j + 1) = num_rp_below m j + 1 from h1
done
lemma num_rp_below_step_not_rp {m j : Nat} (h : ¬rel_prime m j) :
num_rp_below m (j + 1) = num_rp_below m j := by
have h1 : num_rp_below m (j +1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : ¬gcd m j = 1
rewrite [if_neg h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j
show num_rp_below m (j + 1) = num_rp_below m j from h1
done
lemma phi_def (m : Nat) : phi m = num_rp_below m m := by rfl
#eval phi 10 --Answer: 4
lemma prod_inv_iff_inv {m : Nat} {X : ZMod m}
(h1 : invertible X) (Y : ZMod m) :
invertible (X * Y) ↔ invertible Y := by
apply Iff.intro
· -- (→)
assume h2 : invertible (X * Y)
obtain (Z : ZMod m) (h3 : X * Y * Z = [1]_m) from h2
apply Exists.intro (X * Z)
rewrite [←h3] --Goal : Y * (X * Z) = X * Y * Z
ring --Note that ring can do algebra in ZMod m
done
· -- (←)
assume h2 : invertible Y
obtain (Xi : ZMod m) (h3 : X * Xi = [1]_m) from h1
obtain (Yi : ZMod m) (h4 : Y * Yi = [1]_m) from h2
apply Exists.intro (Xi * Yi)
show (X * Y) * (Xi * Yi) = [1]_m from
calc X * Y * (Xi * Yi)
_ = (X * Xi) * (Y * Yi) := by ring
_ = [1]_m * [1]_m := by rw [h3, h4]
_ = [1]_m := Theorem_7_3_6_7 [1]_m
done
done
lemma F_rp_def {m i : Nat} (h : rel_prime m i) :
F m i = [i]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h --h : gcd m i = 1
rewrite [if_pos h] at h1
show F m i = [i]_m from h1
done
lemma F_not_rp_def {m i : Nat} (h : ¬rel_prime m i) :
F m i = [1]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h
rewrite [h1, if_neg h]
rfl
done
lemma prod_seq_base {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 0 k f = [1]_m := by rfl
lemma prod_seq_step {m : Nat}
(n k : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) k f = prod_seq n k f * f (k + n) := by rfl
lemma prod_seq_zero_step {m : Nat}
(n : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) 0 f = prod_seq n 0 f * f n := by
rewrite [prod_seq_step, zero_add]
rfl
done
lemma prod_one {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 1 k f = f k := by
rewrite [prod_seq_step, prod_seq_base, add_zero, mul_comm, Theorem_7_3_6_7]
rfl
done
lemma G_def (m a i : Nat) : G m a i = (a * i) % m := by rfl
lemma cc_G (m a i : Nat) : [G m a i]_m = [a]_m * [i]_m :=
calc [G m a i]_m
_ = [(a * i) % m]_m := by rfl
_ = [a * i]_m := (cc_eq_mod m (a * i)).symm
_ = [a]_m * [i]_m := (mul_class m a i).symm
| lemma G_rp_iff {m a : Nat} (h1 : rel_prime m a) (i : Nat) :
rel_prime m (G m a i) ↔ rel_prime m i | HTPI.G_rp_iff | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1180,
"tokenPositionInFile": 37089,
"theoremPositionInFile": 112
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n have h2 : invertible [a]_m := (Theorem_7_3_7 m a).rtl h1\n show rel_prime m (G m a i) ↔ rel_prime m i from\n calc rel_prime m (G m a i)\n _ ↔ invertible [G m a i]_m := (Theorem_7_3_7 m (G m a i)).symm\n _ ↔ invertible ([a]_m * [i]_m) := by rw [cc_G]\n _ ↔ invertible [i]_m := prod_inv_iff_inv h2 ([i]_m)\n _ ↔ rel_prime m i := Theorem_7_3_7 m i\n done",
"proofType": "tactic",
"proofLengthLines": 8,
"proofLengthTokens": 377
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 := by rfl
lemma num_rp_below_step_rp {m j : Nat} (h : rel_prime m j) :
num_rp_below m (j + 1) = (num_rp_below m j) + 1 := by
have h1 : num_rp_below m (j + 1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : gcd m j = 1
rewrite [if_pos h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j + 1
show num_rp_below m (j + 1) = num_rp_below m j + 1 from h1
done
lemma num_rp_below_step_not_rp {m j : Nat} (h : ¬rel_prime m j) :
num_rp_below m (j + 1) = num_rp_below m j := by
have h1 : num_rp_below m (j +1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : ¬gcd m j = 1
rewrite [if_neg h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j
show num_rp_below m (j + 1) = num_rp_below m j from h1
done
lemma phi_def (m : Nat) : phi m = num_rp_below m m := by rfl
#eval phi 10 --Answer: 4
lemma prod_inv_iff_inv {m : Nat} {X : ZMod m}
(h1 : invertible X) (Y : ZMod m) :
invertible (X * Y) ↔ invertible Y := by
apply Iff.intro
· -- (→)
assume h2 : invertible (X * Y)
obtain (Z : ZMod m) (h3 : X * Y * Z = [1]_m) from h2
apply Exists.intro (X * Z)
rewrite [←h3] --Goal : Y * (X * Z) = X * Y * Z
ring --Note that ring can do algebra in ZMod m
done
· -- (←)
assume h2 : invertible Y
obtain (Xi : ZMod m) (h3 : X * Xi = [1]_m) from h1
obtain (Yi : ZMod m) (h4 : Y * Yi = [1]_m) from h2
apply Exists.intro (Xi * Yi)
show (X * Y) * (Xi * Yi) = [1]_m from
calc X * Y * (Xi * Yi)
_ = (X * Xi) * (Y * Yi) := by ring
_ = [1]_m * [1]_m := by rw [h3, h4]
_ = [1]_m := Theorem_7_3_6_7 [1]_m
done
done
lemma F_rp_def {m i : Nat} (h : rel_prime m i) :
F m i = [i]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h --h : gcd m i = 1
rewrite [if_pos h] at h1
show F m i = [i]_m from h1
done
lemma F_not_rp_def {m i : Nat} (h : ¬rel_prime m i) :
F m i = [1]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h
rewrite [h1, if_neg h]
rfl
done
lemma prod_seq_base {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 0 k f = [1]_m := by rfl
lemma prod_seq_step {m : Nat}
(n k : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) k f = prod_seq n k f * f (k + n) := by rfl
lemma prod_seq_zero_step {m : Nat}
(n : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) 0 f = prod_seq n 0 f * f n := by
rewrite [prod_seq_step, zero_add]
rfl
done
lemma prod_one {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 1 k f = f k := by
rewrite [prod_seq_step, prod_seq_base, add_zero, mul_comm, Theorem_7_3_6_7]
rfl
done
lemma G_def (m a i : Nat) : G m a i = (a * i) % m := by rfl
lemma cc_G (m a i : Nat) : [G m a i]_m = [a]_m * [i]_m :=
calc [G m a i]_m
_ = [(a * i) % m]_m := by rfl
_ = [a * i]_m := (cc_eq_mod m (a * i)).symm
_ = [a]_m * [i]_m := (mul_class m a i).symm
lemma G_rp_iff {m a : Nat} (h1 : rel_prime m a) (i : Nat) :
rel_prime m (G m a i) ↔ rel_prime m i := by
have h2 : invertible [a]_m := (Theorem_7_3_7 m a).rtl h1
show rel_prime m (G m a i) ↔ rel_prime m i from
calc rel_prime m (G m a i)
_ ↔ invertible [G m a i]_m := (Theorem_7_3_7 m (G m a i)).symm
_ ↔ invertible ([a]_m * [i]_m) := by rw [cc_G]
_ ↔ invertible [i]_m := prod_inv_iff_inv h2 ([i]_m)
_ ↔ rel_prime m i := Theorem_7_3_7 m i
done
| lemma FG_rp {m a i : Nat} (h1 : rel_prime m a) (h2 : rel_prime m i) :
F m (G m a i) = [a]_m * F m i | HTPI.FG_rp | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1191,
"tokenPositionInFile": 37570,
"theoremPositionInFile": 113
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n have h3 : rel_prime m (G m a i) := (G_rp_iff h1 i).rtl h2\n show F m (G m a i) = [a]_m * F m i from\n calc F m (G m a i)\n _ = [G m a i]_m := F_rp_def h3\n _ = [a]_m * [i]_m := cc_G m a i\n _ = [a]_m * F m i := by rw [F_rp_def h2]\n done",
"proofType": "tactic",
"proofLengthLines": 7,
"proofLengthTokens": 259
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 := by rfl
lemma num_rp_below_step_rp {m j : Nat} (h : rel_prime m j) :
num_rp_below m (j + 1) = (num_rp_below m j) + 1 := by
have h1 : num_rp_below m (j + 1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : gcd m j = 1
rewrite [if_pos h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j + 1
show num_rp_below m (j + 1) = num_rp_below m j + 1 from h1
done
lemma num_rp_below_step_not_rp {m j : Nat} (h : ¬rel_prime m j) :
num_rp_below m (j + 1) = num_rp_below m j := by
have h1 : num_rp_below m (j +1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : ¬gcd m j = 1
rewrite [if_neg h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j
show num_rp_below m (j + 1) = num_rp_below m j from h1
done
lemma phi_def (m : Nat) : phi m = num_rp_below m m := by rfl
#eval phi 10 --Answer: 4
lemma prod_inv_iff_inv {m : Nat} {X : ZMod m}
(h1 : invertible X) (Y : ZMod m) :
invertible (X * Y) ↔ invertible Y := by
apply Iff.intro
· -- (→)
assume h2 : invertible (X * Y)
obtain (Z : ZMod m) (h3 : X * Y * Z = [1]_m) from h2
apply Exists.intro (X * Z)
rewrite [←h3] --Goal : Y * (X * Z) = X * Y * Z
ring --Note that ring can do algebra in ZMod m
done
· -- (←)
assume h2 : invertible Y
obtain (Xi : ZMod m) (h3 : X * Xi = [1]_m) from h1
obtain (Yi : ZMod m) (h4 : Y * Yi = [1]_m) from h2
apply Exists.intro (Xi * Yi)
show (X * Y) * (Xi * Yi) = [1]_m from
calc X * Y * (Xi * Yi)
_ = (X * Xi) * (Y * Yi) := by ring
_ = [1]_m * [1]_m := by rw [h3, h4]
_ = [1]_m := Theorem_7_3_6_7 [1]_m
done
done
lemma F_rp_def {m i : Nat} (h : rel_prime m i) :
F m i = [i]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h --h : gcd m i = 1
rewrite [if_pos h] at h1
show F m i = [i]_m from h1
done
lemma F_not_rp_def {m i : Nat} (h : ¬rel_prime m i) :
F m i = [1]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h
rewrite [h1, if_neg h]
rfl
done
lemma prod_seq_base {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 0 k f = [1]_m := by rfl
lemma prod_seq_step {m : Nat}
(n k : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) k f = prod_seq n k f * f (k + n) := by rfl
lemma prod_seq_zero_step {m : Nat}
(n : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) 0 f = prod_seq n 0 f * f n := by
rewrite [prod_seq_step, zero_add]
rfl
done
lemma prod_one {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 1 k f = f k := by
rewrite [prod_seq_step, prod_seq_base, add_zero, mul_comm, Theorem_7_3_6_7]
rfl
done
lemma G_def (m a i : Nat) : G m a i = (a * i) % m := by rfl
lemma cc_G (m a i : Nat) : [G m a i]_m = [a]_m * [i]_m :=
calc [G m a i]_m
_ = [(a * i) % m]_m := by rfl
_ = [a * i]_m := (cc_eq_mod m (a * i)).symm
_ = [a]_m * [i]_m := (mul_class m a i).symm
lemma G_rp_iff {m a : Nat} (h1 : rel_prime m a) (i : Nat) :
rel_prime m (G m a i) ↔ rel_prime m i := by
have h2 : invertible [a]_m := (Theorem_7_3_7 m a).rtl h1
show rel_prime m (G m a i) ↔ rel_prime m i from
calc rel_prime m (G m a i)
_ ↔ invertible [G m a i]_m := (Theorem_7_3_7 m (G m a i)).symm
_ ↔ invertible ([a]_m * [i]_m) := by rw [cc_G]
_ ↔ invertible [i]_m := prod_inv_iff_inv h2 ([i]_m)
_ ↔ rel_prime m i := Theorem_7_3_7 m i
done
lemma FG_rp {m a i : Nat} (h1 : rel_prime m a) (h2 : rel_prime m i) :
F m (G m a i) = [a]_m * F m i := by
have h3 : rel_prime m (G m a i) := (G_rp_iff h1 i).rtl h2
show F m (G m a i) = [a]_m * F m i from
calc F m (G m a i)
_ = [G m a i]_m := F_rp_def h3
_ = [a]_m * [i]_m := cc_G m a i
_ = [a]_m * F m i := by rw [F_rp_def h2]
done
| lemma FG_not_rp {m a i : Nat} (h1 : rel_prime m a) (h2 : ¬rel_prime m i) :
F m (G m a i) = [1]_m | HTPI.FG_not_rp | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1201,
"tokenPositionInFile": 37935,
"theoremPositionInFile": 114
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n rewrite [←G_rp_iff h1 i] at h2\n show F m (G m a i) = [1]_m from F_not_rp_def h2\n done",
"proofType": "tactic",
"proofLengthLines": 3,
"proofLengthTokens": 95
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 := by rfl
lemma num_rp_below_step_rp {m j : Nat} (h : rel_prime m j) :
num_rp_below m (j + 1) = (num_rp_below m j) + 1 := by
have h1 : num_rp_below m (j + 1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : gcd m j = 1
rewrite [if_pos h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j + 1
show num_rp_below m (j + 1) = num_rp_below m j + 1 from h1
done
lemma num_rp_below_step_not_rp {m j : Nat} (h : ¬rel_prime m j) :
num_rp_below m (j + 1) = num_rp_below m j := by
have h1 : num_rp_below m (j +1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : ¬gcd m j = 1
rewrite [if_neg h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j
show num_rp_below m (j + 1) = num_rp_below m j from h1
done
lemma phi_def (m : Nat) : phi m = num_rp_below m m := by rfl
#eval phi 10 --Answer: 4
lemma prod_inv_iff_inv {m : Nat} {X : ZMod m}
(h1 : invertible X) (Y : ZMod m) :
invertible (X * Y) ↔ invertible Y := by
apply Iff.intro
· -- (→)
assume h2 : invertible (X * Y)
obtain (Z : ZMod m) (h3 : X * Y * Z = [1]_m) from h2
apply Exists.intro (X * Z)
rewrite [←h3] --Goal : Y * (X * Z) = X * Y * Z
ring --Note that ring can do algebra in ZMod m
done
· -- (←)
assume h2 : invertible Y
obtain (Xi : ZMod m) (h3 : X * Xi = [1]_m) from h1
obtain (Yi : ZMod m) (h4 : Y * Yi = [1]_m) from h2
apply Exists.intro (Xi * Yi)
show (X * Y) * (Xi * Yi) = [1]_m from
calc X * Y * (Xi * Yi)
_ = (X * Xi) * (Y * Yi) := by ring
_ = [1]_m * [1]_m := by rw [h3, h4]
_ = [1]_m := Theorem_7_3_6_7 [1]_m
done
done
lemma F_rp_def {m i : Nat} (h : rel_prime m i) :
F m i = [i]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h --h : gcd m i = 1
rewrite [if_pos h] at h1
show F m i = [i]_m from h1
done
lemma F_not_rp_def {m i : Nat} (h : ¬rel_prime m i) :
F m i = [1]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h
rewrite [h1, if_neg h]
rfl
done
lemma prod_seq_base {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 0 k f = [1]_m := by rfl
lemma prod_seq_step {m : Nat}
(n k : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) k f = prod_seq n k f * f (k + n) := by rfl
lemma prod_seq_zero_step {m : Nat}
(n : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) 0 f = prod_seq n 0 f * f n := by
rewrite [prod_seq_step, zero_add]
rfl
done
lemma prod_one {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 1 k f = f k := by
rewrite [prod_seq_step, prod_seq_base, add_zero, mul_comm, Theorem_7_3_6_7]
rfl
done
lemma G_def (m a i : Nat) : G m a i = (a * i) % m := by rfl
lemma cc_G (m a i : Nat) : [G m a i]_m = [a]_m * [i]_m :=
calc [G m a i]_m
_ = [(a * i) % m]_m := by rfl
_ = [a * i]_m := (cc_eq_mod m (a * i)).symm
_ = [a]_m * [i]_m := (mul_class m a i).symm
lemma G_rp_iff {m a : Nat} (h1 : rel_prime m a) (i : Nat) :
rel_prime m (G m a i) ↔ rel_prime m i := by
have h2 : invertible [a]_m := (Theorem_7_3_7 m a).rtl h1
show rel_prime m (G m a i) ↔ rel_prime m i from
calc rel_prime m (G m a i)
_ ↔ invertible [G m a i]_m := (Theorem_7_3_7 m (G m a i)).symm
_ ↔ invertible ([a]_m * [i]_m) := by rw [cc_G]
_ ↔ invertible [i]_m := prod_inv_iff_inv h2 ([i]_m)
_ ↔ rel_prime m i := Theorem_7_3_7 m i
done
lemma FG_rp {m a i : Nat} (h1 : rel_prime m a) (h2 : rel_prime m i) :
F m (G m a i) = [a]_m * F m i := by
have h3 : rel_prime m (G m a i) := (G_rp_iff h1 i).rtl h2
show F m (G m a i) = [a]_m * F m i from
calc F m (G m a i)
_ = [G m a i]_m := F_rp_def h3
_ = [a]_m * [i]_m := cc_G m a i
_ = [a]_m * F m i := by rw [F_rp_def h2]
done
lemma FG_not_rp {m a i : Nat} (h1 : rel_prime m a) (h2 : ¬rel_prime m i) :
F m (G m a i) = [1]_m := by
rewrite [←G_rp_iff h1 i] at h2
show F m (G m a i) = [1]_m from F_not_rp_def h2
done
| lemma FG_prod {m a : Nat} (h1 : rel_prime m a) :
∀ (k : Nat), prod_seq k 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) | HTPI.FG_prod | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1207,
"tokenPositionInFile": 38133,
"theoremPositionInFile": 115
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n by_induc\n · -- Base Case\n show prod_seq 0 0 ((F m) ∘ (G m a)) =\n [a]_m ^ (num_rp_below m 0) * prod_seq 0 0 (F m) from\n calc prod_seq 0 0 ((F m) ∘ (G m a))\n _ = [1]_m := prod_seq_base _ _\n _ = [a]_m ^ 0 * [1]_m := by ring\n _ = [a]_m ^ (num_rp_below m 0) * prod_seq 0 0 (F m) := by\n rw [num_rp_below_base, prod_seq_base]\n done\n · -- Induction Step\n fix k : Nat\n assume ih : prod_seq k 0 ((F m) ∘ (G m a)) =\n [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m)\n by_cases h2 : rel_prime m k\n · -- Case 1. h2 : rel_prime m k\n show prod_seq (k + 1) 0 ((F m) ∘ (G m a)) =\n [a]_m ^ (num_rp_below m (k + 1)) *\n prod_seq (k + 1) 0 (F m) from\n calc prod_seq (k + 1) 0 ((F m) ∘ (G m a))\n _ = prod_seq k 0 ((F m) ∘ (G m a)) *\n F m (G m a k) := prod_seq_zero_step _ _\n _ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *\n F m (G m a k) := by rw [ih]\n _ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *\n ([a]_m * F m k) := by rw [FG_rp h1 h2]\n _ = [a]_m ^ ((num_rp_below m k) + 1) *\n ((prod_seq k 0 (F m)) * F m k) := by ring\n _ = [a]_m ^ (num_rp_below m (k + 1)) *\n prod_seq (k + 1) 0 (F m) := by\n rw [num_rp_below_step_rp h2, prod_seq_zero_step]\n done\n · -- Case 2. h2 : ¬rel_prime m k\n show prod_seq (k + 1) 0 ((F m) ∘ (G m a)) =\n [a]_m ^ (num_rp_below m (k + 1)) *\n prod_seq (k + 1) 0 (F m) from\n calc prod_seq (k + 1) 0 ((F m) ∘ (G m a))\n _ = prod_seq k 0 ((F m) ∘ (G m a)) *\n F m (G m a k) := prod_seq_zero_step _ _\n _ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *\n F m (G m a k) := by rw [ih]\n _ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *\n ([1]_m) := by rw [FG_not_rp h1 h2]\n _ = [a]_m ^ (num_rp_below m k) *\n (prod_seq k 0 (F m) * ([1]_m)) := by ring\n _ = [a]_m ^ (num_rp_below m (k + 1)) *\n prod_seq (k + 1) 0 (F m) := by\n rw [num_rp_below_step_not_rp h2, prod_seq_zero_step,\n F_not_rp_def h2]\n done\n done\n done",
"proofType": "tactic",
"proofLengthLines": 52,
"proofLengthTokens": 2244
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 := by rfl
lemma num_rp_below_step_rp {m j : Nat} (h : rel_prime m j) :
num_rp_below m (j + 1) = (num_rp_below m j) + 1 := by
have h1 : num_rp_below m (j + 1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : gcd m j = 1
rewrite [if_pos h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j + 1
show num_rp_below m (j + 1) = num_rp_below m j + 1 from h1
done
lemma num_rp_below_step_not_rp {m j : Nat} (h : ¬rel_prime m j) :
num_rp_below m (j + 1) = num_rp_below m j := by
have h1 : num_rp_below m (j +1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : ¬gcd m j = 1
rewrite [if_neg h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j
show num_rp_below m (j + 1) = num_rp_below m j from h1
done
lemma phi_def (m : Nat) : phi m = num_rp_below m m := by rfl
#eval phi 10 --Answer: 4
lemma prod_inv_iff_inv {m : Nat} {X : ZMod m}
(h1 : invertible X) (Y : ZMod m) :
invertible (X * Y) ↔ invertible Y := by
apply Iff.intro
· -- (→)
assume h2 : invertible (X * Y)
obtain (Z : ZMod m) (h3 : X * Y * Z = [1]_m) from h2
apply Exists.intro (X * Z)
rewrite [←h3] --Goal : Y * (X * Z) = X * Y * Z
ring --Note that ring can do algebra in ZMod m
done
· -- (←)
assume h2 : invertible Y
obtain (Xi : ZMod m) (h3 : X * Xi = [1]_m) from h1
obtain (Yi : ZMod m) (h4 : Y * Yi = [1]_m) from h2
apply Exists.intro (Xi * Yi)
show (X * Y) * (Xi * Yi) = [1]_m from
calc X * Y * (Xi * Yi)
_ = (X * Xi) * (Y * Yi) := by ring
_ = [1]_m * [1]_m := by rw [h3, h4]
_ = [1]_m := Theorem_7_3_6_7 [1]_m
done
done
lemma F_rp_def {m i : Nat} (h : rel_prime m i) :
F m i = [i]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h --h : gcd m i = 1
rewrite [if_pos h] at h1
show F m i = [i]_m from h1
done
lemma F_not_rp_def {m i : Nat} (h : ¬rel_prime m i) :
F m i = [1]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h
rewrite [h1, if_neg h]
rfl
done
lemma prod_seq_base {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 0 k f = [1]_m := by rfl
lemma prod_seq_step {m : Nat}
(n k : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) k f = prod_seq n k f * f (k + n) := by rfl
lemma prod_seq_zero_step {m : Nat}
(n : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) 0 f = prod_seq n 0 f * f n := by
rewrite [prod_seq_step, zero_add]
rfl
done
lemma prod_one {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 1 k f = f k := by
rewrite [prod_seq_step, prod_seq_base, add_zero, mul_comm, Theorem_7_3_6_7]
rfl
done
lemma G_def (m a i : Nat) : G m a i = (a * i) % m := by rfl
lemma cc_G (m a i : Nat) : [G m a i]_m = [a]_m * [i]_m :=
calc [G m a i]_m
_ = [(a * i) % m]_m := by rfl
_ = [a * i]_m := (cc_eq_mod m (a * i)).symm
_ = [a]_m * [i]_m := (mul_class m a i).symm
lemma G_rp_iff {m a : Nat} (h1 : rel_prime m a) (i : Nat) :
rel_prime m (G m a i) ↔ rel_prime m i := by
have h2 : invertible [a]_m := (Theorem_7_3_7 m a).rtl h1
show rel_prime m (G m a i) ↔ rel_prime m i from
calc rel_prime m (G m a i)
_ ↔ invertible [G m a i]_m := (Theorem_7_3_7 m (G m a i)).symm
_ ↔ invertible ([a]_m * [i]_m) := by rw [cc_G]
_ ↔ invertible [i]_m := prod_inv_iff_inv h2 ([i]_m)
_ ↔ rel_prime m i := Theorem_7_3_7 m i
done
lemma FG_rp {m a i : Nat} (h1 : rel_prime m a) (h2 : rel_prime m i) :
F m (G m a i) = [a]_m * F m i := by
have h3 : rel_prime m (G m a i) := (G_rp_iff h1 i).rtl h2
show F m (G m a i) = [a]_m * F m i from
calc F m (G m a i)
_ = [G m a i]_m := F_rp_def h3
_ = [a]_m * [i]_m := cc_G m a i
_ = [a]_m * F m i := by rw [F_rp_def h2]
done
lemma FG_not_rp {m a i : Nat} (h1 : rel_prime m a) (h2 : ¬rel_prime m i) :
F m (G m a i) = [1]_m := by
rewrite [←G_rp_iff h1 i] at h2
show F m (G m a i) = [1]_m from F_not_rp_def h2
done
lemma FG_prod {m a : Nat} (h1 : rel_prime m a) :
∀ (k : Nat), prod_seq k 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) := by
by_induc
· -- Base Case
show prod_seq 0 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m 0) * prod_seq 0 0 (F m) from
calc prod_seq 0 0 ((F m) ∘ (G m a))
_ = [1]_m := prod_seq_base _ _
_ = [a]_m ^ 0 * [1]_m := by ring
_ = [a]_m ^ (num_rp_below m 0) * prod_seq 0 0 (F m) := by
rw [num_rp_below_base, prod_seq_base]
done
· -- Induction Step
fix k : Nat
assume ih : prod_seq k 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m)
by_cases h2 : rel_prime m k
· -- Case 1. h2 : rel_prime m k
show prod_seq (k + 1) 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) from
calc prod_seq (k + 1) 0 ((F m) ∘ (G m a))
_ = prod_seq k 0 ((F m) ∘ (G m a)) *
F m (G m a k) := prod_seq_zero_step _ _
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
F m (G m a k) := by rw [ih]
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
([a]_m * F m k) := by rw [FG_rp h1 h2]
_ = [a]_m ^ ((num_rp_below m k) + 1) *
((prod_seq k 0 (F m)) * F m k) := by ring
_ = [a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) := by
rw [num_rp_below_step_rp h2, prod_seq_zero_step]
done
· -- Case 2. h2 : ¬rel_prime m k
show prod_seq (k + 1) 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) from
calc prod_seq (k + 1) 0 ((F m) ∘ (G m a))
_ = prod_seq k 0 ((F m) ∘ (G m a)) *
F m (G m a k) := prod_seq_zero_step _ _
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
F m (G m a k) := by rw [ih]
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
([1]_m) := by rw [FG_not_rp h1 h2]
_ = [a]_m ^ (num_rp_below m k) *
(prod_seq k 0 (F m) * ([1]_m)) := by ring
_ = [a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) := by
rw [num_rp_below_step_not_rp h2, prod_seq_zero_step,
F_not_rp_def h2]
done
done
done
| lemma G_maps_below (m a : Nat) [NeZero m] : maps_below m (G m a) | HTPI.G_maps_below | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1263,
"tokenPositionInFile": 40532,
"theoremPositionInFile": 116
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n define --Goal : ∀ i < m, G m a i < m\n fix i : Nat\n assume h1 : i < m\n rewrite [G_def] --Goal : a * i % m < m\n show a * i % m < m from mod_nonzero_lt (a * i) (NeZero.ne m)\n done",
"proofType": "tactic",
"proofLengthLines": 6,
"proofLengthTokens": 204
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 := by rfl
lemma num_rp_below_step_rp {m j : Nat} (h : rel_prime m j) :
num_rp_below m (j + 1) = (num_rp_below m j) + 1 := by
have h1 : num_rp_below m (j + 1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : gcd m j = 1
rewrite [if_pos h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j + 1
show num_rp_below m (j + 1) = num_rp_below m j + 1 from h1
done
lemma num_rp_below_step_not_rp {m j : Nat} (h : ¬rel_prime m j) :
num_rp_below m (j + 1) = num_rp_below m j := by
have h1 : num_rp_below m (j +1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : ¬gcd m j = 1
rewrite [if_neg h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j
show num_rp_below m (j + 1) = num_rp_below m j from h1
done
lemma phi_def (m : Nat) : phi m = num_rp_below m m := by rfl
#eval phi 10 --Answer: 4
lemma prod_inv_iff_inv {m : Nat} {X : ZMod m}
(h1 : invertible X) (Y : ZMod m) :
invertible (X * Y) ↔ invertible Y := by
apply Iff.intro
· -- (→)
assume h2 : invertible (X * Y)
obtain (Z : ZMod m) (h3 : X * Y * Z = [1]_m) from h2
apply Exists.intro (X * Z)
rewrite [←h3] --Goal : Y * (X * Z) = X * Y * Z
ring --Note that ring can do algebra in ZMod m
done
· -- (←)
assume h2 : invertible Y
obtain (Xi : ZMod m) (h3 : X * Xi = [1]_m) from h1
obtain (Yi : ZMod m) (h4 : Y * Yi = [1]_m) from h2
apply Exists.intro (Xi * Yi)
show (X * Y) * (Xi * Yi) = [1]_m from
calc X * Y * (Xi * Yi)
_ = (X * Xi) * (Y * Yi) := by ring
_ = [1]_m * [1]_m := by rw [h3, h4]
_ = [1]_m := Theorem_7_3_6_7 [1]_m
done
done
lemma F_rp_def {m i : Nat} (h : rel_prime m i) :
F m i = [i]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h --h : gcd m i = 1
rewrite [if_pos h] at h1
show F m i = [i]_m from h1
done
lemma F_not_rp_def {m i : Nat} (h : ¬rel_prime m i) :
F m i = [1]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h
rewrite [h1, if_neg h]
rfl
done
lemma prod_seq_base {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 0 k f = [1]_m := by rfl
lemma prod_seq_step {m : Nat}
(n k : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) k f = prod_seq n k f * f (k + n) := by rfl
lemma prod_seq_zero_step {m : Nat}
(n : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) 0 f = prod_seq n 0 f * f n := by
rewrite [prod_seq_step, zero_add]
rfl
done
lemma prod_one {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 1 k f = f k := by
rewrite [prod_seq_step, prod_seq_base, add_zero, mul_comm, Theorem_7_3_6_7]
rfl
done
lemma G_def (m a i : Nat) : G m a i = (a * i) % m := by rfl
lemma cc_G (m a i : Nat) : [G m a i]_m = [a]_m * [i]_m :=
calc [G m a i]_m
_ = [(a * i) % m]_m := by rfl
_ = [a * i]_m := (cc_eq_mod m (a * i)).symm
_ = [a]_m * [i]_m := (mul_class m a i).symm
lemma G_rp_iff {m a : Nat} (h1 : rel_prime m a) (i : Nat) :
rel_prime m (G m a i) ↔ rel_prime m i := by
have h2 : invertible [a]_m := (Theorem_7_3_7 m a).rtl h1
show rel_prime m (G m a i) ↔ rel_prime m i from
calc rel_prime m (G m a i)
_ ↔ invertible [G m a i]_m := (Theorem_7_3_7 m (G m a i)).symm
_ ↔ invertible ([a]_m * [i]_m) := by rw [cc_G]
_ ↔ invertible [i]_m := prod_inv_iff_inv h2 ([i]_m)
_ ↔ rel_prime m i := Theorem_7_3_7 m i
done
lemma FG_rp {m a i : Nat} (h1 : rel_prime m a) (h2 : rel_prime m i) :
F m (G m a i) = [a]_m * F m i := by
have h3 : rel_prime m (G m a i) := (G_rp_iff h1 i).rtl h2
show F m (G m a i) = [a]_m * F m i from
calc F m (G m a i)
_ = [G m a i]_m := F_rp_def h3
_ = [a]_m * [i]_m := cc_G m a i
_ = [a]_m * F m i := by rw [F_rp_def h2]
done
lemma FG_not_rp {m a i : Nat} (h1 : rel_prime m a) (h2 : ¬rel_prime m i) :
F m (G m a i) = [1]_m := by
rewrite [←G_rp_iff h1 i] at h2
show F m (G m a i) = [1]_m from F_not_rp_def h2
done
lemma FG_prod {m a : Nat} (h1 : rel_prime m a) :
∀ (k : Nat), prod_seq k 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) := by
by_induc
· -- Base Case
show prod_seq 0 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m 0) * prod_seq 0 0 (F m) from
calc prod_seq 0 0 ((F m) ∘ (G m a))
_ = [1]_m := prod_seq_base _ _
_ = [a]_m ^ 0 * [1]_m := by ring
_ = [a]_m ^ (num_rp_below m 0) * prod_seq 0 0 (F m) := by
rw [num_rp_below_base, prod_seq_base]
done
· -- Induction Step
fix k : Nat
assume ih : prod_seq k 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m)
by_cases h2 : rel_prime m k
· -- Case 1. h2 : rel_prime m k
show prod_seq (k + 1) 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) from
calc prod_seq (k + 1) 0 ((F m) ∘ (G m a))
_ = prod_seq k 0 ((F m) ∘ (G m a)) *
F m (G m a k) := prod_seq_zero_step _ _
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
F m (G m a k) := by rw [ih]
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
([a]_m * F m k) := by rw [FG_rp h1 h2]
_ = [a]_m ^ ((num_rp_below m k) + 1) *
((prod_seq k 0 (F m)) * F m k) := by ring
_ = [a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) := by
rw [num_rp_below_step_rp h2, prod_seq_zero_step]
done
· -- Case 2. h2 : ¬rel_prime m k
show prod_seq (k + 1) 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) from
calc prod_seq (k + 1) 0 ((F m) ∘ (G m a))
_ = prod_seq k 0 ((F m) ∘ (G m a)) *
F m (G m a k) := prod_seq_zero_step _ _
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
F m (G m a k) := by rw [ih]
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
([1]_m) := by rw [FG_not_rp h1 h2]
_ = [a]_m ^ (num_rp_below m k) *
(prod_seq k 0 (F m) * ([1]_m)) := by ring
_ = [a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) := by
rw [num_rp_below_step_not_rp h2, prod_seq_zero_step,
F_not_rp_def h2]
done
done
done
lemma G_maps_below (m a : Nat) [NeZero m] : maps_below m (G m a) := by
define --Goal : ∀ i < m, G m a i < m
fix i : Nat
assume h1 : i < m
rewrite [G_def] --Goal : a * i % m < m
show a * i % m < m from mod_nonzero_lt (a * i) (NeZero.ne m)
done
| lemma left_inv_one_one_below {n : Nat} {g g' : Nat → Nat}
(h1 : ∀ i < n, g' (g i) = i) : one_one_below n g | HTPI.left_inv_one_one_below | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1271,
"tokenPositionInFile": 40803,
"theoremPositionInFile": 117
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": false,
"proof": ":= sorry",
"proofType": "term",
"proofLengthLines": 0,
"proofLengthTokens": 8
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 := by rfl
lemma num_rp_below_step_rp {m j : Nat} (h : rel_prime m j) :
num_rp_below m (j + 1) = (num_rp_below m j) + 1 := by
have h1 : num_rp_below m (j + 1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : gcd m j = 1
rewrite [if_pos h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j + 1
show num_rp_below m (j + 1) = num_rp_below m j + 1 from h1
done
lemma num_rp_below_step_not_rp {m j : Nat} (h : ¬rel_prime m j) :
num_rp_below m (j + 1) = num_rp_below m j := by
have h1 : num_rp_below m (j +1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : ¬gcd m j = 1
rewrite [if_neg h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j
show num_rp_below m (j + 1) = num_rp_below m j from h1
done
lemma phi_def (m : Nat) : phi m = num_rp_below m m := by rfl
#eval phi 10 --Answer: 4
lemma prod_inv_iff_inv {m : Nat} {X : ZMod m}
(h1 : invertible X) (Y : ZMod m) :
invertible (X * Y) ↔ invertible Y := by
apply Iff.intro
· -- (→)
assume h2 : invertible (X * Y)
obtain (Z : ZMod m) (h3 : X * Y * Z = [1]_m) from h2
apply Exists.intro (X * Z)
rewrite [←h3] --Goal : Y * (X * Z) = X * Y * Z
ring --Note that ring can do algebra in ZMod m
done
· -- (←)
assume h2 : invertible Y
obtain (Xi : ZMod m) (h3 : X * Xi = [1]_m) from h1
obtain (Yi : ZMod m) (h4 : Y * Yi = [1]_m) from h2
apply Exists.intro (Xi * Yi)
show (X * Y) * (Xi * Yi) = [1]_m from
calc X * Y * (Xi * Yi)
_ = (X * Xi) * (Y * Yi) := by ring
_ = [1]_m * [1]_m := by rw [h3, h4]
_ = [1]_m := Theorem_7_3_6_7 [1]_m
done
done
lemma F_rp_def {m i : Nat} (h : rel_prime m i) :
F m i = [i]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h --h : gcd m i = 1
rewrite [if_pos h] at h1
show F m i = [i]_m from h1
done
lemma F_not_rp_def {m i : Nat} (h : ¬rel_prime m i) :
F m i = [1]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h
rewrite [h1, if_neg h]
rfl
done
lemma prod_seq_base {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 0 k f = [1]_m := by rfl
lemma prod_seq_step {m : Nat}
(n k : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) k f = prod_seq n k f * f (k + n) := by rfl
lemma prod_seq_zero_step {m : Nat}
(n : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) 0 f = prod_seq n 0 f * f n := by
rewrite [prod_seq_step, zero_add]
rfl
done
lemma prod_one {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 1 k f = f k := by
rewrite [prod_seq_step, prod_seq_base, add_zero, mul_comm, Theorem_7_3_6_7]
rfl
done
lemma G_def (m a i : Nat) : G m a i = (a * i) % m := by rfl
lemma cc_G (m a i : Nat) : [G m a i]_m = [a]_m * [i]_m :=
calc [G m a i]_m
_ = [(a * i) % m]_m := by rfl
_ = [a * i]_m := (cc_eq_mod m (a * i)).symm
_ = [a]_m * [i]_m := (mul_class m a i).symm
lemma G_rp_iff {m a : Nat} (h1 : rel_prime m a) (i : Nat) :
rel_prime m (G m a i) ↔ rel_prime m i := by
have h2 : invertible [a]_m := (Theorem_7_3_7 m a).rtl h1
show rel_prime m (G m a i) ↔ rel_prime m i from
calc rel_prime m (G m a i)
_ ↔ invertible [G m a i]_m := (Theorem_7_3_7 m (G m a i)).symm
_ ↔ invertible ([a]_m * [i]_m) := by rw [cc_G]
_ ↔ invertible [i]_m := prod_inv_iff_inv h2 ([i]_m)
_ ↔ rel_prime m i := Theorem_7_3_7 m i
done
lemma FG_rp {m a i : Nat} (h1 : rel_prime m a) (h2 : rel_prime m i) :
F m (G m a i) = [a]_m * F m i := by
have h3 : rel_prime m (G m a i) := (G_rp_iff h1 i).rtl h2
show F m (G m a i) = [a]_m * F m i from
calc F m (G m a i)
_ = [G m a i]_m := F_rp_def h3
_ = [a]_m * [i]_m := cc_G m a i
_ = [a]_m * F m i := by rw [F_rp_def h2]
done
lemma FG_not_rp {m a i : Nat} (h1 : rel_prime m a) (h2 : ¬rel_prime m i) :
F m (G m a i) = [1]_m := by
rewrite [←G_rp_iff h1 i] at h2
show F m (G m a i) = [1]_m from F_not_rp_def h2
done
lemma FG_prod {m a : Nat} (h1 : rel_prime m a) :
∀ (k : Nat), prod_seq k 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) := by
by_induc
· -- Base Case
show prod_seq 0 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m 0) * prod_seq 0 0 (F m) from
calc prod_seq 0 0 ((F m) ∘ (G m a))
_ = [1]_m := prod_seq_base _ _
_ = [a]_m ^ 0 * [1]_m := by ring
_ = [a]_m ^ (num_rp_below m 0) * prod_seq 0 0 (F m) := by
rw [num_rp_below_base, prod_seq_base]
done
· -- Induction Step
fix k : Nat
assume ih : prod_seq k 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m)
by_cases h2 : rel_prime m k
· -- Case 1. h2 : rel_prime m k
show prod_seq (k + 1) 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) from
calc prod_seq (k + 1) 0 ((F m) ∘ (G m a))
_ = prod_seq k 0 ((F m) ∘ (G m a)) *
F m (G m a k) := prod_seq_zero_step _ _
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
F m (G m a k) := by rw [ih]
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
([a]_m * F m k) := by rw [FG_rp h1 h2]
_ = [a]_m ^ ((num_rp_below m k) + 1) *
((prod_seq k 0 (F m)) * F m k) := by ring
_ = [a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) := by
rw [num_rp_below_step_rp h2, prod_seq_zero_step]
done
· -- Case 2. h2 : ¬rel_prime m k
show prod_seq (k + 1) 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) from
calc prod_seq (k + 1) 0 ((F m) ∘ (G m a))
_ = prod_seq k 0 ((F m) ∘ (G m a)) *
F m (G m a k) := prod_seq_zero_step _ _
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
F m (G m a k) := by rw [ih]
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
([1]_m) := by rw [FG_not_rp h1 h2]
_ = [a]_m ^ (num_rp_below m k) *
(prod_seq k 0 (F m) * ([1]_m)) := by ring
_ = [a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) := by
rw [num_rp_below_step_not_rp h2, prod_seq_zero_step,
F_not_rp_def h2]
done
done
done
lemma G_maps_below (m a : Nat) [NeZero m] : maps_below m (G m a) := by
define --Goal : ∀ i < m, G m a i < m
fix i : Nat
assume h1 : i < m
rewrite [G_def] --Goal : a * i % m < m
show a * i % m < m from mod_nonzero_lt (a * i) (NeZero.ne m)
done
lemma left_inv_one_one_below {n : Nat} {g g' : Nat → Nat}
(h1 : ∀ i < n, g' (g i) = i) : one_one_below n g := sorry
| lemma right_inv_onto_below {n : Nat} {g g' : Nat → Nat}
(h1 : ∀ i < n, g (g' i) = i) (h2 : maps_below n g') :
onto_below n g | HTPI.right_inv_onto_below | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1274,
"tokenPositionInFile": 40924,
"theoremPositionInFile": 118
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n define at h2; define\n fix k : Nat\n assume h3 : k < n\n apply Exists.intro (g' k)\n show g' k < n ∧ g (g' k) = k from And.intro (h2 k h3) (h1 k h3)\n done",
"proofType": "tactic",
"proofLengthLines": 6,
"proofLengthTokens": 163
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 := by rfl
lemma num_rp_below_step_rp {m j : Nat} (h : rel_prime m j) :
num_rp_below m (j + 1) = (num_rp_below m j) + 1 := by
have h1 : num_rp_below m (j + 1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : gcd m j = 1
rewrite [if_pos h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j + 1
show num_rp_below m (j + 1) = num_rp_below m j + 1 from h1
done
lemma num_rp_below_step_not_rp {m j : Nat} (h : ¬rel_prime m j) :
num_rp_below m (j + 1) = num_rp_below m j := by
have h1 : num_rp_below m (j +1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : ¬gcd m j = 1
rewrite [if_neg h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j
show num_rp_below m (j + 1) = num_rp_below m j from h1
done
lemma phi_def (m : Nat) : phi m = num_rp_below m m := by rfl
#eval phi 10 --Answer: 4
lemma prod_inv_iff_inv {m : Nat} {X : ZMod m}
(h1 : invertible X) (Y : ZMod m) :
invertible (X * Y) ↔ invertible Y := by
apply Iff.intro
· -- (→)
assume h2 : invertible (X * Y)
obtain (Z : ZMod m) (h3 : X * Y * Z = [1]_m) from h2
apply Exists.intro (X * Z)
rewrite [←h3] --Goal : Y * (X * Z) = X * Y * Z
ring --Note that ring can do algebra in ZMod m
done
· -- (←)
assume h2 : invertible Y
obtain (Xi : ZMod m) (h3 : X * Xi = [1]_m) from h1
obtain (Yi : ZMod m) (h4 : Y * Yi = [1]_m) from h2
apply Exists.intro (Xi * Yi)
show (X * Y) * (Xi * Yi) = [1]_m from
calc X * Y * (Xi * Yi)
_ = (X * Xi) * (Y * Yi) := by ring
_ = [1]_m * [1]_m := by rw [h3, h4]
_ = [1]_m := Theorem_7_3_6_7 [1]_m
done
done
lemma F_rp_def {m i : Nat} (h : rel_prime m i) :
F m i = [i]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h --h : gcd m i = 1
rewrite [if_pos h] at h1
show F m i = [i]_m from h1
done
lemma F_not_rp_def {m i : Nat} (h : ¬rel_prime m i) :
F m i = [1]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h
rewrite [h1, if_neg h]
rfl
done
lemma prod_seq_base {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 0 k f = [1]_m := by rfl
lemma prod_seq_step {m : Nat}
(n k : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) k f = prod_seq n k f * f (k + n) := by rfl
lemma prod_seq_zero_step {m : Nat}
(n : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) 0 f = prod_seq n 0 f * f n := by
rewrite [prod_seq_step, zero_add]
rfl
done
lemma prod_one {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 1 k f = f k := by
rewrite [prod_seq_step, prod_seq_base, add_zero, mul_comm, Theorem_7_3_6_7]
rfl
done
lemma G_def (m a i : Nat) : G m a i = (a * i) % m := by rfl
lemma cc_G (m a i : Nat) : [G m a i]_m = [a]_m * [i]_m :=
calc [G m a i]_m
_ = [(a * i) % m]_m := by rfl
_ = [a * i]_m := (cc_eq_mod m (a * i)).symm
_ = [a]_m * [i]_m := (mul_class m a i).symm
lemma G_rp_iff {m a : Nat} (h1 : rel_prime m a) (i : Nat) :
rel_prime m (G m a i) ↔ rel_prime m i := by
have h2 : invertible [a]_m := (Theorem_7_3_7 m a).rtl h1
show rel_prime m (G m a i) ↔ rel_prime m i from
calc rel_prime m (G m a i)
_ ↔ invertible [G m a i]_m := (Theorem_7_3_7 m (G m a i)).symm
_ ↔ invertible ([a]_m * [i]_m) := by rw [cc_G]
_ ↔ invertible [i]_m := prod_inv_iff_inv h2 ([i]_m)
_ ↔ rel_prime m i := Theorem_7_3_7 m i
done
lemma FG_rp {m a i : Nat} (h1 : rel_prime m a) (h2 : rel_prime m i) :
F m (G m a i) = [a]_m * F m i := by
have h3 : rel_prime m (G m a i) := (G_rp_iff h1 i).rtl h2
show F m (G m a i) = [a]_m * F m i from
calc F m (G m a i)
_ = [G m a i]_m := F_rp_def h3
_ = [a]_m * [i]_m := cc_G m a i
_ = [a]_m * F m i := by rw [F_rp_def h2]
done
lemma FG_not_rp {m a i : Nat} (h1 : rel_prime m a) (h2 : ¬rel_prime m i) :
F m (G m a i) = [1]_m := by
rewrite [←G_rp_iff h1 i] at h2
show F m (G m a i) = [1]_m from F_not_rp_def h2
done
lemma FG_prod {m a : Nat} (h1 : rel_prime m a) :
∀ (k : Nat), prod_seq k 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) := by
by_induc
· -- Base Case
show prod_seq 0 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m 0) * prod_seq 0 0 (F m) from
calc prod_seq 0 0 ((F m) ∘ (G m a))
_ = [1]_m := prod_seq_base _ _
_ = [a]_m ^ 0 * [1]_m := by ring
_ = [a]_m ^ (num_rp_below m 0) * prod_seq 0 0 (F m) := by
rw [num_rp_below_base, prod_seq_base]
done
· -- Induction Step
fix k : Nat
assume ih : prod_seq k 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m)
by_cases h2 : rel_prime m k
· -- Case 1. h2 : rel_prime m k
show prod_seq (k + 1) 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) from
calc prod_seq (k + 1) 0 ((F m) ∘ (G m a))
_ = prod_seq k 0 ((F m) ∘ (G m a)) *
F m (G m a k) := prod_seq_zero_step _ _
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
F m (G m a k) := by rw [ih]
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
([a]_m * F m k) := by rw [FG_rp h1 h2]
_ = [a]_m ^ ((num_rp_below m k) + 1) *
((prod_seq k 0 (F m)) * F m k) := by ring
_ = [a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) := by
rw [num_rp_below_step_rp h2, prod_seq_zero_step]
done
· -- Case 2. h2 : ¬rel_prime m k
show prod_seq (k + 1) 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) from
calc prod_seq (k + 1) 0 ((F m) ∘ (G m a))
_ = prod_seq k 0 ((F m) ∘ (G m a)) *
F m (G m a k) := prod_seq_zero_step _ _
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
F m (G m a k) := by rw [ih]
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
([1]_m) := by rw [FG_not_rp h1 h2]
_ = [a]_m ^ (num_rp_below m k) *
(prod_seq k 0 (F m) * ([1]_m)) := by ring
_ = [a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) := by
rw [num_rp_below_step_not_rp h2, prod_seq_zero_step,
F_not_rp_def h2]
done
done
done
lemma G_maps_below (m a : Nat) [NeZero m] : maps_below m (G m a) := by
define --Goal : ∀ i < m, G m a i < m
fix i : Nat
assume h1 : i < m
rewrite [G_def] --Goal : a * i % m < m
show a * i % m < m from mod_nonzero_lt (a * i) (NeZero.ne m)
done
lemma left_inv_one_one_below {n : Nat} {g g' : Nat → Nat}
(h1 : ∀ i < n, g' (g i) = i) : one_one_below n g := sorry
lemma right_inv_onto_below {n : Nat} {g g' : Nat → Nat}
(h1 : ∀ i < n, g (g' i) = i) (h2 : maps_below n g') :
onto_below n g := by
define at h2; define
fix k : Nat
assume h3 : k < n
apply Exists.intro (g' k)
show g' k < n ∧ g (g' k) = k from And.intro (h2 k h3) (h1 k h3)
done
| lemma cc_mul_inv_mod_eq_one {m a : Nat} [NeZero m] (h1 : rel_prime m a) :
[a]_m * [inv_mod m a]_m = [1]_m | HTPI.cc_mul_inv_mod_eq_one | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1284,
"tokenPositionInFile": 41222,
"theoremPositionInFile": 119
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n have h2 : 0 ≤ (gcd_c2 m a) % m := mod_nonneg m (gcd_c2 m a)\n show [a]_m * [inv_mod m a]_m = [1]_m from\n calc [a]_m * [inv_mod m a]_m\n _ = [a]_m * [Int.toNat ((gcd_c2 m a) % m)]_m := by rfl\n _ = [a]_m * [(gcd_c2 m a) % m]_m := by rw [Int.toNat_of_nonneg h2]\n _ = [a]_m * [gcd_c2 m a]_m := by rw [←cc_eq_mod]\n _ = [1]_m := gcd_c2_inv h1\n done",
"proofType": "tactic",
"proofLengthLines": 8,
"proofLengthTokens": 373
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 := by rfl
lemma num_rp_below_step_rp {m j : Nat} (h : rel_prime m j) :
num_rp_below m (j + 1) = (num_rp_below m j) + 1 := by
have h1 : num_rp_below m (j + 1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : gcd m j = 1
rewrite [if_pos h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j + 1
show num_rp_below m (j + 1) = num_rp_below m j + 1 from h1
done
lemma num_rp_below_step_not_rp {m j : Nat} (h : ¬rel_prime m j) :
num_rp_below m (j + 1) = num_rp_below m j := by
have h1 : num_rp_below m (j +1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : ¬gcd m j = 1
rewrite [if_neg h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j
show num_rp_below m (j + 1) = num_rp_below m j from h1
done
lemma phi_def (m : Nat) : phi m = num_rp_below m m := by rfl
#eval phi 10 --Answer: 4
lemma prod_inv_iff_inv {m : Nat} {X : ZMod m}
(h1 : invertible X) (Y : ZMod m) :
invertible (X * Y) ↔ invertible Y := by
apply Iff.intro
· -- (→)
assume h2 : invertible (X * Y)
obtain (Z : ZMod m) (h3 : X * Y * Z = [1]_m) from h2
apply Exists.intro (X * Z)
rewrite [←h3] --Goal : Y * (X * Z) = X * Y * Z
ring --Note that ring can do algebra in ZMod m
done
· -- (←)
assume h2 : invertible Y
obtain (Xi : ZMod m) (h3 : X * Xi = [1]_m) from h1
obtain (Yi : ZMod m) (h4 : Y * Yi = [1]_m) from h2
apply Exists.intro (Xi * Yi)
show (X * Y) * (Xi * Yi) = [1]_m from
calc X * Y * (Xi * Yi)
_ = (X * Xi) * (Y * Yi) := by ring
_ = [1]_m * [1]_m := by rw [h3, h4]
_ = [1]_m := Theorem_7_3_6_7 [1]_m
done
done
lemma F_rp_def {m i : Nat} (h : rel_prime m i) :
F m i = [i]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h --h : gcd m i = 1
rewrite [if_pos h] at h1
show F m i = [i]_m from h1
done
lemma F_not_rp_def {m i : Nat} (h : ¬rel_prime m i) :
F m i = [1]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h
rewrite [h1, if_neg h]
rfl
done
lemma prod_seq_base {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 0 k f = [1]_m := by rfl
lemma prod_seq_step {m : Nat}
(n k : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) k f = prod_seq n k f * f (k + n) := by rfl
lemma prod_seq_zero_step {m : Nat}
(n : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) 0 f = prod_seq n 0 f * f n := by
rewrite [prod_seq_step, zero_add]
rfl
done
lemma prod_one {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 1 k f = f k := by
rewrite [prod_seq_step, prod_seq_base, add_zero, mul_comm, Theorem_7_3_6_7]
rfl
done
lemma G_def (m a i : Nat) : G m a i = (a * i) % m := by rfl
lemma cc_G (m a i : Nat) : [G m a i]_m = [a]_m * [i]_m :=
calc [G m a i]_m
_ = [(a * i) % m]_m := by rfl
_ = [a * i]_m := (cc_eq_mod m (a * i)).symm
_ = [a]_m * [i]_m := (mul_class m a i).symm
lemma G_rp_iff {m a : Nat} (h1 : rel_prime m a) (i : Nat) :
rel_prime m (G m a i) ↔ rel_prime m i := by
have h2 : invertible [a]_m := (Theorem_7_3_7 m a).rtl h1
show rel_prime m (G m a i) ↔ rel_prime m i from
calc rel_prime m (G m a i)
_ ↔ invertible [G m a i]_m := (Theorem_7_3_7 m (G m a i)).symm
_ ↔ invertible ([a]_m * [i]_m) := by rw [cc_G]
_ ↔ invertible [i]_m := prod_inv_iff_inv h2 ([i]_m)
_ ↔ rel_prime m i := Theorem_7_3_7 m i
done
lemma FG_rp {m a i : Nat} (h1 : rel_prime m a) (h2 : rel_prime m i) :
F m (G m a i) = [a]_m * F m i := by
have h3 : rel_prime m (G m a i) := (G_rp_iff h1 i).rtl h2
show F m (G m a i) = [a]_m * F m i from
calc F m (G m a i)
_ = [G m a i]_m := F_rp_def h3
_ = [a]_m * [i]_m := cc_G m a i
_ = [a]_m * F m i := by rw [F_rp_def h2]
done
lemma FG_not_rp {m a i : Nat} (h1 : rel_prime m a) (h2 : ¬rel_prime m i) :
F m (G m a i) = [1]_m := by
rewrite [←G_rp_iff h1 i] at h2
show F m (G m a i) = [1]_m from F_not_rp_def h2
done
lemma FG_prod {m a : Nat} (h1 : rel_prime m a) :
∀ (k : Nat), prod_seq k 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) := by
by_induc
· -- Base Case
show prod_seq 0 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m 0) * prod_seq 0 0 (F m) from
calc prod_seq 0 0 ((F m) ∘ (G m a))
_ = [1]_m := prod_seq_base _ _
_ = [a]_m ^ 0 * [1]_m := by ring
_ = [a]_m ^ (num_rp_below m 0) * prod_seq 0 0 (F m) := by
rw [num_rp_below_base, prod_seq_base]
done
· -- Induction Step
fix k : Nat
assume ih : prod_seq k 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m)
by_cases h2 : rel_prime m k
· -- Case 1. h2 : rel_prime m k
show prod_seq (k + 1) 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) from
calc prod_seq (k + 1) 0 ((F m) ∘ (G m a))
_ = prod_seq k 0 ((F m) ∘ (G m a)) *
F m (G m a k) := prod_seq_zero_step _ _
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
F m (G m a k) := by rw [ih]
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
([a]_m * F m k) := by rw [FG_rp h1 h2]
_ = [a]_m ^ ((num_rp_below m k) + 1) *
((prod_seq k 0 (F m)) * F m k) := by ring
_ = [a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) := by
rw [num_rp_below_step_rp h2, prod_seq_zero_step]
done
· -- Case 2. h2 : ¬rel_prime m k
show prod_seq (k + 1) 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) from
calc prod_seq (k + 1) 0 ((F m) ∘ (G m a))
_ = prod_seq k 0 ((F m) ∘ (G m a)) *
F m (G m a k) := prod_seq_zero_step _ _
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
F m (G m a k) := by rw [ih]
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
([1]_m) := by rw [FG_not_rp h1 h2]
_ = [a]_m ^ (num_rp_below m k) *
(prod_seq k 0 (F m) * ([1]_m)) := by ring
_ = [a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) := by
rw [num_rp_below_step_not_rp h2, prod_seq_zero_step,
F_not_rp_def h2]
done
done
done
lemma G_maps_below (m a : Nat) [NeZero m] : maps_below m (G m a) := by
define --Goal : ∀ i < m, G m a i < m
fix i : Nat
assume h1 : i < m
rewrite [G_def] --Goal : a * i % m < m
show a * i % m < m from mod_nonzero_lt (a * i) (NeZero.ne m)
done
lemma left_inv_one_one_below {n : Nat} {g g' : Nat → Nat}
(h1 : ∀ i < n, g' (g i) = i) : one_one_below n g := sorry
lemma right_inv_onto_below {n : Nat} {g g' : Nat → Nat}
(h1 : ∀ i < n, g (g' i) = i) (h2 : maps_below n g') :
onto_below n g := by
define at h2; define
fix k : Nat
assume h3 : k < n
apply Exists.intro (g' k)
show g' k < n ∧ g (g' k) = k from And.intro (h2 k h3) (h1 k h3)
done
lemma cc_mul_inv_mod_eq_one {m a : Nat} [NeZero m] (h1 : rel_prime m a) :
[a]_m * [inv_mod m a]_m = [1]_m := by
have h2 : 0 ≤ (gcd_c2 m a) % m := mod_nonneg m (gcd_c2 m a)
show [a]_m * [inv_mod m a]_m = [1]_m from
calc [a]_m * [inv_mod m a]_m
_ = [a]_m * [Int.toNat ((gcd_c2 m a) % m)]_m := by rfl
_ = [a]_m * [(gcd_c2 m a) % m]_m := by rw [Int.toNat_of_nonneg h2]
_ = [a]_m * [gcd_c2 m a]_m := by rw [←cc_eq_mod]
_ = [1]_m := gcd_c2_inv h1
done
| lemma mul_mod_mod_eq_mul_mod (m a b : Nat) : (a * (b % m)) % m = (a * b) % m | HTPI.mul_mod_mod_eq_mul_mod | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1295,
"tokenPositionInFile": 41707,
"theoremPositionInFile": 120
} | {
"inFilePremises": false,
"repositoryPremises": false
} | {
"hasProof": true,
"proof": ":=\n calc a * (b % m) % m\n = a % m * (b % m % m) % m := Nat.mul_mod _ _ _\n _ = a % m * (b % m) % m := by rw [Nat.mod_mod]\n _ = a * b % m := (Nat.mul_mod _ _ _).symm",
"proofType": "term",
"proofLengthLines": 4,
"proofLengthTokens": 175
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 := by rfl
lemma num_rp_below_step_rp {m j : Nat} (h : rel_prime m j) :
num_rp_below m (j + 1) = (num_rp_below m j) + 1 := by
have h1 : num_rp_below m (j + 1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : gcd m j = 1
rewrite [if_pos h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j + 1
show num_rp_below m (j + 1) = num_rp_below m j + 1 from h1
done
lemma num_rp_below_step_not_rp {m j : Nat} (h : ¬rel_prime m j) :
num_rp_below m (j + 1) = num_rp_below m j := by
have h1 : num_rp_below m (j +1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : ¬gcd m j = 1
rewrite [if_neg h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j
show num_rp_below m (j + 1) = num_rp_below m j from h1
done
lemma phi_def (m : Nat) : phi m = num_rp_below m m := by rfl
#eval phi 10 --Answer: 4
lemma prod_inv_iff_inv {m : Nat} {X : ZMod m}
(h1 : invertible X) (Y : ZMod m) :
invertible (X * Y) ↔ invertible Y := by
apply Iff.intro
· -- (→)
assume h2 : invertible (X * Y)
obtain (Z : ZMod m) (h3 : X * Y * Z = [1]_m) from h2
apply Exists.intro (X * Z)
rewrite [←h3] --Goal : Y * (X * Z) = X * Y * Z
ring --Note that ring can do algebra in ZMod m
done
· -- (←)
assume h2 : invertible Y
obtain (Xi : ZMod m) (h3 : X * Xi = [1]_m) from h1
obtain (Yi : ZMod m) (h4 : Y * Yi = [1]_m) from h2
apply Exists.intro (Xi * Yi)
show (X * Y) * (Xi * Yi) = [1]_m from
calc X * Y * (Xi * Yi)
_ = (X * Xi) * (Y * Yi) := by ring
_ = [1]_m * [1]_m := by rw [h3, h4]
_ = [1]_m := Theorem_7_3_6_7 [1]_m
done
done
lemma F_rp_def {m i : Nat} (h : rel_prime m i) :
F m i = [i]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h --h : gcd m i = 1
rewrite [if_pos h] at h1
show F m i = [i]_m from h1
done
lemma F_not_rp_def {m i : Nat} (h : ¬rel_prime m i) :
F m i = [1]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h
rewrite [h1, if_neg h]
rfl
done
lemma prod_seq_base {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 0 k f = [1]_m := by rfl
lemma prod_seq_step {m : Nat}
(n k : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) k f = prod_seq n k f * f (k + n) := by rfl
lemma prod_seq_zero_step {m : Nat}
(n : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) 0 f = prod_seq n 0 f * f n := by
rewrite [prod_seq_step, zero_add]
rfl
done
lemma prod_one {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 1 k f = f k := by
rewrite [prod_seq_step, prod_seq_base, add_zero, mul_comm, Theorem_7_3_6_7]
rfl
done
lemma G_def (m a i : Nat) : G m a i = (a * i) % m := by rfl
lemma cc_G (m a i : Nat) : [G m a i]_m = [a]_m * [i]_m :=
calc [G m a i]_m
_ = [(a * i) % m]_m := by rfl
_ = [a * i]_m := (cc_eq_mod m (a * i)).symm
_ = [a]_m * [i]_m := (mul_class m a i).symm
lemma G_rp_iff {m a : Nat} (h1 : rel_prime m a) (i : Nat) :
rel_prime m (G m a i) ↔ rel_prime m i := by
have h2 : invertible [a]_m := (Theorem_7_3_7 m a).rtl h1
show rel_prime m (G m a i) ↔ rel_prime m i from
calc rel_prime m (G m a i)
_ ↔ invertible [G m a i]_m := (Theorem_7_3_7 m (G m a i)).symm
_ ↔ invertible ([a]_m * [i]_m) := by rw [cc_G]
_ ↔ invertible [i]_m := prod_inv_iff_inv h2 ([i]_m)
_ ↔ rel_prime m i := Theorem_7_3_7 m i
done
lemma FG_rp {m a i : Nat} (h1 : rel_prime m a) (h2 : rel_prime m i) :
F m (G m a i) = [a]_m * F m i := by
have h3 : rel_prime m (G m a i) := (G_rp_iff h1 i).rtl h2
show F m (G m a i) = [a]_m * F m i from
calc F m (G m a i)
_ = [G m a i]_m := F_rp_def h3
_ = [a]_m * [i]_m := cc_G m a i
_ = [a]_m * F m i := by rw [F_rp_def h2]
done
lemma FG_not_rp {m a i : Nat} (h1 : rel_prime m a) (h2 : ¬rel_prime m i) :
F m (G m a i) = [1]_m := by
rewrite [←G_rp_iff h1 i] at h2
show F m (G m a i) = [1]_m from F_not_rp_def h2
done
lemma FG_prod {m a : Nat} (h1 : rel_prime m a) :
∀ (k : Nat), prod_seq k 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) := by
by_induc
· -- Base Case
show prod_seq 0 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m 0) * prod_seq 0 0 (F m) from
calc prod_seq 0 0 ((F m) ∘ (G m a))
_ = [1]_m := prod_seq_base _ _
_ = [a]_m ^ 0 * [1]_m := by ring
_ = [a]_m ^ (num_rp_below m 0) * prod_seq 0 0 (F m) := by
rw [num_rp_below_base, prod_seq_base]
done
· -- Induction Step
fix k : Nat
assume ih : prod_seq k 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m)
by_cases h2 : rel_prime m k
· -- Case 1. h2 : rel_prime m k
show prod_seq (k + 1) 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) from
calc prod_seq (k + 1) 0 ((F m) ∘ (G m a))
_ = prod_seq k 0 ((F m) ∘ (G m a)) *
F m (G m a k) := prod_seq_zero_step _ _
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
F m (G m a k) := by rw [ih]
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
([a]_m * F m k) := by rw [FG_rp h1 h2]
_ = [a]_m ^ ((num_rp_below m k) + 1) *
((prod_seq k 0 (F m)) * F m k) := by ring
_ = [a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) := by
rw [num_rp_below_step_rp h2, prod_seq_zero_step]
done
· -- Case 2. h2 : ¬rel_prime m k
show prod_seq (k + 1) 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) from
calc prod_seq (k + 1) 0 ((F m) ∘ (G m a))
_ = prod_seq k 0 ((F m) ∘ (G m a)) *
F m (G m a k) := prod_seq_zero_step _ _
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
F m (G m a k) := by rw [ih]
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
([1]_m) := by rw [FG_not_rp h1 h2]
_ = [a]_m ^ (num_rp_below m k) *
(prod_seq k 0 (F m) * ([1]_m)) := by ring
_ = [a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) := by
rw [num_rp_below_step_not_rp h2, prod_seq_zero_step,
F_not_rp_def h2]
done
done
done
lemma G_maps_below (m a : Nat) [NeZero m] : maps_below m (G m a) := by
define --Goal : ∀ i < m, G m a i < m
fix i : Nat
assume h1 : i < m
rewrite [G_def] --Goal : a * i % m < m
show a * i % m < m from mod_nonzero_lt (a * i) (NeZero.ne m)
done
lemma left_inv_one_one_below {n : Nat} {g g' : Nat → Nat}
(h1 : ∀ i < n, g' (g i) = i) : one_one_below n g := sorry
lemma right_inv_onto_below {n : Nat} {g g' : Nat → Nat}
(h1 : ∀ i < n, g (g' i) = i) (h2 : maps_below n g') :
onto_below n g := by
define at h2; define
fix k : Nat
assume h3 : k < n
apply Exists.intro (g' k)
show g' k < n ∧ g (g' k) = k from And.intro (h2 k h3) (h1 k h3)
done
lemma cc_mul_inv_mod_eq_one {m a : Nat} [NeZero m] (h1 : rel_prime m a) :
[a]_m * [inv_mod m a]_m = [1]_m := by
have h2 : 0 ≤ (gcd_c2 m a) % m := mod_nonneg m (gcd_c2 m a)
show [a]_m * [inv_mod m a]_m = [1]_m from
calc [a]_m * [inv_mod m a]_m
_ = [a]_m * [Int.toNat ((gcd_c2 m a) % m)]_m := by rfl
_ = [a]_m * [(gcd_c2 m a) % m]_m := by rw [Int.toNat_of_nonneg h2]
_ = [a]_m * [gcd_c2 m a]_m := by rw [←cc_eq_mod]
_ = [1]_m := gcd_c2_inv h1
done
lemma mul_mod_mod_eq_mul_mod (m a b : Nat) : (a * (b % m)) % m = (a * b) % m :=
calc a * (b % m) % m
= a % m * (b % m % m) % m := Nat.mul_mod _ _ _
_ = a % m * (b % m) % m := by rw [Nat.mod_mod]
_ = a * b % m := (Nat.mul_mod _ _ _).symm
| lemma mod_mul_mod_eq_mul_mod (m a b : Nat) : (a % m * b) % m = (a * b) % m | HTPI.mod_mul_mod_eq_mul_mod | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1301,
"tokenPositionInFile": 41961,
"theoremPositionInFile": 121
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n rewrite [mul_comm, mul_mod_mod_eq_mul_mod, mul_comm]\n rfl\n done",
"proofType": "tactic",
"proofLengthLines": 3,
"proofLengthTokens": 73
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 := by rfl
lemma num_rp_below_step_rp {m j : Nat} (h : rel_prime m j) :
num_rp_below m (j + 1) = (num_rp_below m j) + 1 := by
have h1 : num_rp_below m (j + 1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : gcd m j = 1
rewrite [if_pos h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j + 1
show num_rp_below m (j + 1) = num_rp_below m j + 1 from h1
done
lemma num_rp_below_step_not_rp {m j : Nat} (h : ¬rel_prime m j) :
num_rp_below m (j + 1) = num_rp_below m j := by
have h1 : num_rp_below m (j +1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : ¬gcd m j = 1
rewrite [if_neg h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j
show num_rp_below m (j + 1) = num_rp_below m j from h1
done
lemma phi_def (m : Nat) : phi m = num_rp_below m m := by rfl
#eval phi 10 --Answer: 4
lemma prod_inv_iff_inv {m : Nat} {X : ZMod m}
(h1 : invertible X) (Y : ZMod m) :
invertible (X * Y) ↔ invertible Y := by
apply Iff.intro
· -- (→)
assume h2 : invertible (X * Y)
obtain (Z : ZMod m) (h3 : X * Y * Z = [1]_m) from h2
apply Exists.intro (X * Z)
rewrite [←h3] --Goal : Y * (X * Z) = X * Y * Z
ring --Note that ring can do algebra in ZMod m
done
· -- (←)
assume h2 : invertible Y
obtain (Xi : ZMod m) (h3 : X * Xi = [1]_m) from h1
obtain (Yi : ZMod m) (h4 : Y * Yi = [1]_m) from h2
apply Exists.intro (Xi * Yi)
show (X * Y) * (Xi * Yi) = [1]_m from
calc X * Y * (Xi * Yi)
_ = (X * Xi) * (Y * Yi) := by ring
_ = [1]_m * [1]_m := by rw [h3, h4]
_ = [1]_m := Theorem_7_3_6_7 [1]_m
done
done
lemma F_rp_def {m i : Nat} (h : rel_prime m i) :
F m i = [i]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h --h : gcd m i = 1
rewrite [if_pos h] at h1
show F m i = [i]_m from h1
done
lemma F_not_rp_def {m i : Nat} (h : ¬rel_prime m i) :
F m i = [1]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h
rewrite [h1, if_neg h]
rfl
done
lemma prod_seq_base {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 0 k f = [1]_m := by rfl
lemma prod_seq_step {m : Nat}
(n k : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) k f = prod_seq n k f * f (k + n) := by rfl
lemma prod_seq_zero_step {m : Nat}
(n : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) 0 f = prod_seq n 0 f * f n := by
rewrite [prod_seq_step, zero_add]
rfl
done
lemma prod_one {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 1 k f = f k := by
rewrite [prod_seq_step, prod_seq_base, add_zero, mul_comm, Theorem_7_3_6_7]
rfl
done
lemma G_def (m a i : Nat) : G m a i = (a * i) % m := by rfl
lemma cc_G (m a i : Nat) : [G m a i]_m = [a]_m * [i]_m :=
calc [G m a i]_m
_ = [(a * i) % m]_m := by rfl
_ = [a * i]_m := (cc_eq_mod m (a * i)).symm
_ = [a]_m * [i]_m := (mul_class m a i).symm
lemma G_rp_iff {m a : Nat} (h1 : rel_prime m a) (i : Nat) :
rel_prime m (G m a i) ↔ rel_prime m i := by
have h2 : invertible [a]_m := (Theorem_7_3_7 m a).rtl h1
show rel_prime m (G m a i) ↔ rel_prime m i from
calc rel_prime m (G m a i)
_ ↔ invertible [G m a i]_m := (Theorem_7_3_7 m (G m a i)).symm
_ ↔ invertible ([a]_m * [i]_m) := by rw [cc_G]
_ ↔ invertible [i]_m := prod_inv_iff_inv h2 ([i]_m)
_ ↔ rel_prime m i := Theorem_7_3_7 m i
done
lemma FG_rp {m a i : Nat} (h1 : rel_prime m a) (h2 : rel_prime m i) :
F m (G m a i) = [a]_m * F m i := by
have h3 : rel_prime m (G m a i) := (G_rp_iff h1 i).rtl h2
show F m (G m a i) = [a]_m * F m i from
calc F m (G m a i)
_ = [G m a i]_m := F_rp_def h3
_ = [a]_m * [i]_m := cc_G m a i
_ = [a]_m * F m i := by rw [F_rp_def h2]
done
lemma FG_not_rp {m a i : Nat} (h1 : rel_prime m a) (h2 : ¬rel_prime m i) :
F m (G m a i) = [1]_m := by
rewrite [←G_rp_iff h1 i] at h2
show F m (G m a i) = [1]_m from F_not_rp_def h2
done
lemma FG_prod {m a : Nat} (h1 : rel_prime m a) :
∀ (k : Nat), prod_seq k 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) := by
by_induc
· -- Base Case
show prod_seq 0 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m 0) * prod_seq 0 0 (F m) from
calc prod_seq 0 0 ((F m) ∘ (G m a))
_ = [1]_m := prod_seq_base _ _
_ = [a]_m ^ 0 * [1]_m := by ring
_ = [a]_m ^ (num_rp_below m 0) * prod_seq 0 0 (F m) := by
rw [num_rp_below_base, prod_seq_base]
done
· -- Induction Step
fix k : Nat
assume ih : prod_seq k 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m)
by_cases h2 : rel_prime m k
· -- Case 1. h2 : rel_prime m k
show prod_seq (k + 1) 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) from
calc prod_seq (k + 1) 0 ((F m) ∘ (G m a))
_ = prod_seq k 0 ((F m) ∘ (G m a)) *
F m (G m a k) := prod_seq_zero_step _ _
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
F m (G m a k) := by rw [ih]
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
([a]_m * F m k) := by rw [FG_rp h1 h2]
_ = [a]_m ^ ((num_rp_below m k) + 1) *
((prod_seq k 0 (F m)) * F m k) := by ring
_ = [a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) := by
rw [num_rp_below_step_rp h2, prod_seq_zero_step]
done
· -- Case 2. h2 : ¬rel_prime m k
show prod_seq (k + 1) 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) from
calc prod_seq (k + 1) 0 ((F m) ∘ (G m a))
_ = prod_seq k 0 ((F m) ∘ (G m a)) *
F m (G m a k) := prod_seq_zero_step _ _
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
F m (G m a k) := by rw [ih]
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
([1]_m) := by rw [FG_not_rp h1 h2]
_ = [a]_m ^ (num_rp_below m k) *
(prod_seq k 0 (F m) * ([1]_m)) := by ring
_ = [a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) := by
rw [num_rp_below_step_not_rp h2, prod_seq_zero_step,
F_not_rp_def h2]
done
done
done
lemma G_maps_below (m a : Nat) [NeZero m] : maps_below m (G m a) := by
define --Goal : ∀ i < m, G m a i < m
fix i : Nat
assume h1 : i < m
rewrite [G_def] --Goal : a * i % m < m
show a * i % m < m from mod_nonzero_lt (a * i) (NeZero.ne m)
done
lemma left_inv_one_one_below {n : Nat} {g g' : Nat → Nat}
(h1 : ∀ i < n, g' (g i) = i) : one_one_below n g := sorry
lemma right_inv_onto_below {n : Nat} {g g' : Nat → Nat}
(h1 : ∀ i < n, g (g' i) = i) (h2 : maps_below n g') :
onto_below n g := by
define at h2; define
fix k : Nat
assume h3 : k < n
apply Exists.intro (g' k)
show g' k < n ∧ g (g' k) = k from And.intro (h2 k h3) (h1 k h3)
done
lemma cc_mul_inv_mod_eq_one {m a : Nat} [NeZero m] (h1 : rel_prime m a) :
[a]_m * [inv_mod m a]_m = [1]_m := by
have h2 : 0 ≤ (gcd_c2 m a) % m := mod_nonneg m (gcd_c2 m a)
show [a]_m * [inv_mod m a]_m = [1]_m from
calc [a]_m * [inv_mod m a]_m
_ = [a]_m * [Int.toNat ((gcd_c2 m a) % m)]_m := by rfl
_ = [a]_m * [(gcd_c2 m a) % m]_m := by rw [Int.toNat_of_nonneg h2]
_ = [a]_m * [gcd_c2 m a]_m := by rw [←cc_eq_mod]
_ = [1]_m := gcd_c2_inv h1
done
lemma mul_mod_mod_eq_mul_mod (m a b : Nat) : (a * (b % m)) % m = (a * b) % m :=
calc a * (b % m) % m
= a % m * (b % m % m) % m := Nat.mul_mod _ _ _
_ = a % m * (b % m) % m := by rw [Nat.mod_mod]
_ = a * b % m := (Nat.mul_mod _ _ _).symm
lemma mod_mul_mod_eq_mul_mod (m a b : Nat) : (a % m * b) % m = (a * b) % m := by
rewrite [mul_comm, mul_mod_mod_eq_mul_mod, mul_comm]
rfl
done
| theorem congr_iff_mod_eq_Nat (m a b : Nat) [NeZero m] :
↑a ≡ ↑b (MOD m) ↔ a % m = b % m | HTPI.congr_iff_mod_eq_Nat | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1306,
"tokenPositionInFile": 42111,
"theoremPositionInFile": 122
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": false,
"proof": ":= sorry",
"proofType": "term",
"proofLengthLines": 0,
"proofLengthTokens": 8
} | htpi |
/- Copyright 2023 Daniel J. Velleman -/
import HTPILib.Chap6
namespace HTPI
/- Definitions -/
lemma mod_succ_lt (a n : Nat) : a % (n + 1) < n + 1 := by
have h : n + 1 > 0 := Nat.succ_pos n
show a % (n + 1) < n + 1 from Nat.mod_lt a h
done
def gcd (a b : Nat) : Nat :=
match b with
| 0 => a
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd (n + 1) (a % (n + 1))
termination_by b
mutual
def gcd_c1 (a b : Nat) : Int :=
match b with
| 0 => 1
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c2 (n + 1) (a % (n + 1))
--Corresponds to s = t'
termination_by b
def gcd_c2 (a b : Nat) : Int :=
match b with
| 0 => 0
| n + 1 =>
have : a % (n + 1) < n + 1 := mod_succ_lt a n
gcd_c1 (n + 1) (a % (n + 1)) -
(gcd_c2 (n + 1) (a % (n + 1))) * ↑(a / (n + 1))
--Corresponds to t = s' - t'q
termination_by b
end
def prime (n : Nat) : Prop :=
2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n
def prime_factor (p n : Nat) : Prop := prime p ∧ p ∣ n
def all_prime (l : List Nat) : Prop := ∀ p ∈ l, prime p
def nondec (l : List Nat) : Prop :=
match l with
| [] => True --Of course, True is a proposition that is always true
| n :: L => (∀ m ∈ L, n ≤ m) ∧ nondec L
def nondec_prime_list (l : List Nat) : Prop := all_prime l ∧ nondec l
def prod (l : List Nat) : Nat :=
match l with
| [] => 1
| n :: L => n * (prod L)
def prime_factorization (n : Nat) (l : List Nat) : Prop :=
nondec_prime_list l ∧ prod l = n
def rel_prime (a b : Nat) : Prop := gcd a b = 1
def congr_mod (m : Nat) (a b : Int) : Prop := (↑m : Int) ∣ (a - b)
def cc (m : Nat) (a : Int) : ZMod m := (↑a : ZMod m)
notation:50 a " ≡ " b " (MOD " m ")" => congr_mod m a b
notation:max "["a"]_"m:max => cc m a
def invertible {m : Nat} (X : ZMod m) : Prop :=
∃ (Y : ZMod m), X * Y = [1]_m
def num_rp_below (m k : Nat) : Nat :=
match k with
| 0 => 0
| j + 1 => if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j
def phi (m : Nat) : Nat := num_rp_below m m
def prod_seq {m : Nat}
(j k : Nat) (f : Nat → ZMod m) : ZMod m :=
match j with
| 0 => [1]_m
| n + 1 => prod_seq n k f * f (k + n)
def maps_below (n : Nat) (g : Nat → Nat) : Prop := ∀ i < n, g i < n
def one_one_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ i1 < n, ∀ i2 < n, g i1 = g i2 → i1 = i2
def onto_below (n : Nat) (g : Nat → Nat) : Prop :=
∀ k < n, ∃ i < n, g i = k
def perm_below (n : Nat) (g : Nat → Nat) : Prop :=
maps_below n g ∧ one_one_below n g ∧ onto_below n g
def inv_mod (m a : Nat) : Nat := Int.toNat ((gcd_c2 m a) % m)
def swap (u v i : Nat) : Nat :=
if i = u then v else if i = v then u else i
namespace Euler --For definitions specific to Euler's theorem
def F (m i : Nat) : ZMod m := if gcd m i = 1 then [i]_m else [1]_m
def G (m a i : Nat) : Nat := (a * i) % m
def Ginv (m a i : Nat) : Nat := G m (inv_mod m a) i
end Euler
/- Section 7.1 -/
theorem dvd_mod_of_dvd_a_b {a b d : Nat}
(h1 : d ∣ a) (h2 : d ∣ b) : d ∣ (a % b) := by
set q : Nat := a / b
have h3 : b * q + a % b = a := Nat.div_add_mod a b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
define --Goal : ∃ (c : Nat), a % b = d * c
apply Exists.intro (j - k * q)
show a % b = d * (j - k * q) from
calc a % b
_ = b * q + a % b - b * q := (Nat.add_sub_cancel_left _ _).symm
_ = a - b * q := by rw [h3]
_ = d * j - d * (k * q) := by rw [h4, h5, mul_assoc]
_ = d * (j - k * q) := (Nat.mul_sub_left_distrib _ _ _).symm
done
theorem dvd_a_of_dvd_b_mod {a b d : Nat}
(h1 : d ∣ b) (h2 : d ∣ (a % b)) : d ∣ a := sorry
#eval gcd 672 161 --Answer: 7
lemma gcd_base (a : Nat) : gcd a 0 = a := by rfl
lemma gcd_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd a b = gcd b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2] --Goal : gcd a (n + 1) = gcd (n + 1) (a % (n + 1))
rfl
done
lemma mod_nonzero_lt (a : Nat) {b : Nat} (h : b ≠ 0) : a % b < b := by
have h1 : b > 0 := Nat.pos_of_ne_zero h
show a % b < b from Nat.mod_lt a h1
done
lemma dvd_self (n : Nat) : n ∣ n := by
apply Exists.intro 1
ring
done
theorem gcd_dvd : ∀ (b a : Nat), (gcd a b) ∣ a ∧ (gcd a b) ∣ b := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat), (gcd a b_1) ∣ a ∧ (gcd a b_1) ∣ b_1
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_base] --Goal: a ∣ a ∧ a ∣ 0
apply And.intro (dvd_self a)
define
apply Exists.intro 0
rfl
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_nonzero a h1]
--Goal : gcd b (a % b) ∣ a ∧ gcd b (a % b) ∣ b
have h2 : a % b < b := mod_nonzero_lt a h1
have h3 : (gcd b (a % b)) ∣ b ∧ (gcd b (a % b)) ∣ (a % b) :=
ih (a % b) h2 b
apply And.intro _ h3.left
show (gcd b (a % b)) ∣ a from dvd_a_of_dvd_b_mod h3.left h3.right
done
done
theorem gcd_dvd_left (a b : Nat) : (gcd a b) ∣ a := (gcd_dvd b a).left
theorem gcd_dvd_right (a b : Nat) : (gcd a b) ∣ b := (gcd_dvd b a).right
lemma gcd_c1_base (a : Nat) : gcd_c1 a 0 = 1 := by rfl
lemma gcd_c1_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c1 a b = gcd_c2 b (a % b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
lemma gcd_c2_base (a : Nat) : gcd_c2 a 0 = 0 := by rfl
lemma gcd_c2_nonzero (a : Nat) {b : Nat} (h : b ≠ 0) :
gcd_c2 a b = gcd_c1 b (a % b) - (gcd_c2 b (a % b)) * ↑(a / b) := by
obtain (n : Nat) (h2 : b = n + 1) from exists_eq_add_one_of_ne_zero h
rewrite [h2]
rfl
done
theorem gcd_lin_comb : ∀ (b a : Nat),
(gcd_c1 a b) * ↑a + (gcd_c2 a b) * ↑b = ↑(gcd a b) := by
by_strong_induc
fix b : Nat
assume ih : ∀ b_1 < b, ∀ (a : Nat),
(gcd_c1 a b_1) * ↑a + (gcd_c2 a b_1) * ↑b_1 = ↑(gcd a b_1)
fix a : Nat
by_cases h1 : b = 0
· -- Case 1. h1 : b = 0
rewrite [h1, gcd_c1_base, gcd_c2_base, gcd_base]
--Goal : 1 * ↑a + 0 * ↑0 = ↑a
ring
done
· -- Case 2. h1 : b ≠ 0
rewrite [gcd_c1_nonzero a h1, gcd_c2_nonzero a h1, gcd_nonzero a h1]
--Goal : gcd_c2 b (a % b) * ↑a +
-- (gcd_c1 b (a % b) - gcd_c2 b (a % b) * ↑(a / b)) * ↑b =
-- ↑(gcd b (a % b))
set r : Nat := a % b
set q : Nat := a / b
set s : Int := gcd_c1 b r
set t : Int := gcd_c2 b r
--Goal : t * ↑a + (s - t * ↑q) * ↑b = ↑(gcd b r)
have h2 : r < b := mod_nonzero_lt a h1
have h3 : s * ↑b + t * ↑r = ↑(gcd b r) := ih r h2 b
have h4 : b * q + r = a := Nat.div_add_mod a b
rewrite [←h3, ←h4]
rewrite [Nat.cast_add, Nat.cast_mul]
--Goal : t * (↑b * ↑q + ↑r) + (s - t * ↑q) * ↑b = s * ↑b + t * ↑r
ring
done
done
#eval gcd_c1 672 161 --Answer: 6
#eval gcd_c2 672 161 --Answer: -25
--Note 6 * 672 - 25 * 161 = 4032 - 4025 = 7 = gcd 672 161
theorem Theorem_7_1_6 {d a b : Nat} (h1 : d ∣ a) (h2 : d ∣ b) :
d ∣ gcd a b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑d ∣ ↑(gcd a b)
set s : Int := gcd_c1 a b
set t : Int := gcd_c2 a b
have h3 : s * ↑a + t * ↑b = ↑(gcd a b) := gcd_lin_comb b a
rewrite [←h3] --Goal : ↑d ∣ s * ↑a + t * ↑b
obtain (j : Nat) (h4 : a = d * j) from h1
obtain (k : Nat) (h5 : b = d * k) from h2
rewrite [h4, h5, Nat.cast_mul, Nat.cast_mul]
--Goal : ↑d ∣ s * (↑d * ↑j) + t * (↑d * ↑k)
define
apply Exists.intro (s * ↑j + t * ↑k)
ring
done
/- Section 7.2 -/
theorem dvd_trans {a b c : Nat} (h1 : a ∣ b) (h2 : b ∣ c) : a ∣ c := by
define at h1; define at h2; define
obtain (m : Nat) (h3 : b = a * m) from h1
obtain (n : Nat) (h4 : c = b * n) from h2
rewrite [h3, mul_assoc] at h4
apply Exists.intro (m * n)
show c = a * (m * n) from h4
done
lemma exists_prime_factor : ∀ (n : Nat), 2 ≤ n →
∃ (p : Nat), prime_factor p n := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, 2 ≤ n_1 → ∃ (p : Nat), prime_factor p n_1
assume h1 : 2 ≤ n
by_cases h2 : prime n
· -- Case 1. h2 : prime n
apply Exists.intro n
define --Goal : prime n ∧ n ∣ n
show prime n ∧ n ∣ n from And.intro h2 (dvd_self n)
done
· -- Case 2. h2 : ¬prime n
define at h2
--h2 : ¬(2 ≤ n ∧ ¬∃ (a b : Nat), a * b = n ∧ a < n ∧ b < n)
demorgan at h2
disj_syll h2 h1
obtain (a : Nat) (h3 : ∃ (b : Nat), a * b = n ∧ a < n ∧ b < n) from h2
obtain (b : Nat) (h4 : a * b = n ∧ a < n ∧ b < n) from h3
have h5 : 2 ≤ a := by
by_contra h6
have h7 : a ≤ 1 := by linarith
have h8 : n ≤ b :=
calc n
_ = a * b := h4.left.symm
_ ≤ 1 * b := by rel [h7]
_ = b := by ring
linarith --n ≤ b contradicts b < n
done
have h6 : ∃ (p : Nat), prime_factor p a := ih a h4.right.left h5
obtain (p : Nat) (h7 : prime_factor p a) from h6
apply Exists.intro p
define --Goal : prime p ∧ p ∣ n
define at h7 --h7 : prime p ∧ p ∣ a
apply And.intro h7.left
have h8 : a ∣ n := by
apply Exists.intro b
show n = a * b from (h4.left).symm
done
show p ∣ n from dvd_trans h7.right h8
done
done
lemma exists_least_prime_factor {n : Nat} (h : 2 ≤ n) :
∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q := by
set S : Set Nat := {p : Nat | prime_factor p n}
have h2 : ∃ (p : Nat), p ∈ S := exists_prime_factor n h
show ∃ (p : Nat), prime_factor p n ∧
∀ (q : Nat), prime_factor q n → p ≤ q from well_ord_princ S h2
done
lemma all_prime_nil : all_prime [] := by
define --Goal : ∀ p ∈ [], prime p
fix p : Nat
contrapos --Goal : ¬prime p → p ∉ []
assume h1 : ¬prime p
show p ∉ [] from List.not_mem_nil p
done
lemma all_prime_cons (n : Nat) (L : List Nat) :
all_prime (n :: L) ↔ prime n ∧ all_prime L := by
apply Iff.intro
· -- (→)
assume h1 : all_prime (n :: L) --Goal : prime n ∧ all_prime L
define at h1 --h1 : ∀ p ∈ n :: L, prime p
apply And.intro (h1 n (List.mem_cons_self n L))
define --Goal : ∀ p ∈ L, prime p
fix p : Nat
assume h2 : p ∈ L
show prime p from h1 p (List.mem_cons_of_mem n h2)
done
· -- (←)
assume h1 : prime n ∧ all_prime L --Goal : all_prime (n :: l)
define : all_prime L at h1
define
fix p : Nat
assume h2 : p ∈ n :: L
rewrite [List.mem_cons] at h2 --h2 : p = n ∨ p ∈ L
by_cases on h2
· -- Case 1. h2 : p = n
rewrite [h2]
show prime n from h1.left
done
· -- Case 2. h2 : p ∈ L
show prime p from h1.right p h2
done
done
done
lemma nondec_nil : nondec [] := by
define --Goal : True
trivial --trivial proves some obviously true statements, such as True
done
lemma nondec_cons (n : Nat) (L : List Nat) :
nondec (n :: L) ↔ (∀ m ∈ L, n ≤ m) ∧ nondec L := by rfl
lemma prod_nil : prod [] = 1 := by rfl
lemma prod_cons : prod (n :: L) = n * (prod L) := by rfl
lemma exists_cons_of_length_eq_succ {A : Type}
{l : List A} {n : Nat} (h : l.length = n + 1) :
∃ (a : A) (L : List A), l = a :: L ∧ L.length = n := by
have h1 : ¬l.length = 0 := by linarith
rewrite [List.length_eq_zero] at h1
obtain (a : A) (h2 : ∃ (L : List A), l = a :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List A) (h3 : l = a :: L) from h2
apply Exists.intro a
apply Exists.intro L
apply And.intro h3
have h4 : (a :: L).length = L.length + 1 := List.length_cons a L
rewrite [←h3, h] at h4
show L.length = n from (Nat.add_right_cancel h4).symm
done
lemma list_elt_dvd_prod_by_length (a : Nat) : ∀ (n : Nat),
∀ (l : List Nat), l.length = n → a ∈ l → a ∣ prod l := by
by_induc
· --Base Case
fix l : List Nat
assume h1 : l.length = 0
rewrite [List.length_eq_zero] at h1 --h1 : l = []
rewrite [h1] --Goal : a ∈ [] → a ∣ prod []
contrapos
assume h2 : ¬a ∣ prod []
show a ∉ [] from List.not_mem_nil a
done
· -- Induction Step
fix n : Nat
assume ih : ∀ (l : List Nat), List.length l = n → a ∈ l → a ∣ prod l
fix l : List Nat
assume h1 : l.length = n + 1 --Goal : a ∈ l → a ∣ prod l
obtain (b : Nat) (h2 : ∃ (L : List Nat),
l = b :: L ∧ L.length = n) from exists_cons_of_length_eq_succ h1
obtain (L : List Nat) (h3 : l = b :: L ∧ L.length = n) from h2
have h4 : a ∈ L → a ∣ prod L := ih L h3.right
assume h5 : a ∈ l
rewrite [h3.left, prod_cons] --Goal : a ∣ b * prod L
rewrite [h3.left, List.mem_cons] at h5 --h5 : a = b ∨ a ∈ L
by_cases on h5
· -- Case 1. h5 : a = b
apply Exists.intro (prod L)
rewrite [h5]
rfl
done
· -- Case 2. h5 : a ∈ L
have h6 : a ∣ prod L := h4 h5
have h7 : prod L ∣ b * prod L := by
apply Exists.intro b
ring
done
show a ∣ b * prod L from dvd_trans h6 h7
done
done
done
lemma list_elt_dvd_prod {a : Nat} {l : List Nat}
(h : a ∈ l) : a ∣ prod l := by
set n : Nat := l.length
have h1 : l.length = n := by rfl
show a ∣ prod l from list_elt_dvd_prod_by_length a n l h1 h
done
lemma exists_prime_factorization : ∀ (n : Nat), n ≥ 1 →
∃ (l : List Nat), prime_factorization n l := by
by_strong_induc
fix n : Nat
assume ih : ∀ n_1 < n, n_1 ≥ 1 →
∃ (l : List Nat), prime_factorization n_1 l
assume h1 : n ≥ 1
by_cases h2 : n = 1
· -- Case 1. h2 : n = 1
apply Exists.intro []
define
apply And.intro
· -- Proof of nondec_prime_list []
define
show all_prime [] ∧ nondec [] from
And.intro all_prime_nil nondec_nil
done
· -- Proof of prod [] = n
rewrite [prod_nil, h2]
rfl
done
done
· -- Case 2. h2 : n ≠ 1
have h3 : n ≥ 2 := lt_of_le_of_ne' h1 h2
obtain (p : Nat) (h4 : prime_factor p n ∧ ∀ (q : Nat),
prime_factor q n → p ≤ q) from exists_least_prime_factor h3
have p_prime_factor : prime_factor p n := h4.left
define at p_prime_factor
have p_prime : prime p := p_prime_factor.left
have p_dvd_n : p ∣ n := p_prime_factor.right
have p_least : ∀ (q : Nat), prime_factor q n → p ≤ q := h4.right
obtain (m : Nat) (n_eq_pm : n = p * m) from p_dvd_n
have h5 : m ≠ 0 := by
contradict h1 with h6
have h7 : n = 0 :=
calc n
_ = p * m := n_eq_pm
_ = p * 0 := by rw [h6]
_ = 0 := by ring
rewrite [h7]
decide
done
have m_pos : 0 < m := Nat.pos_of_ne_zero h5
have m_lt_n : m < n := by
define at p_prime
show m < n from
calc m
_ < m + m := by linarith
_ = 2 * m := by ring
_ ≤ p * m := by rel [p_prime.left]
_ = n := n_eq_pm.symm
done
obtain (L : List Nat) (h6 : prime_factorization m L)
from ih m m_lt_n m_pos
define at h6
have ndpl_L : nondec_prime_list L := h6.left
define at ndpl_L
apply Exists.intro (p :: L)
define
apply And.intro
· -- Proof of nondec_prime_list (p :: L)
define
apply And.intro
· -- Proof of all_prime (p :: L)
rewrite [all_prime_cons]
show prime p ∧ all_prime L from And.intro p_prime ndpl_L.left
done
· -- Proof of nondec (p :: L)
rewrite [nondec_cons]
apply And.intro _ ndpl_L.right
fix q : Nat
assume q_in_L : q ∈ L
have h7 : q ∣ prod L := list_elt_dvd_prod q_in_L
rewrite [h6.right] at h7 --h7 : q ∣ m
have h8 : m ∣ n := by
apply Exists.intro p
rewrite [n_eq_pm]
ring
done
have q_dvd_n : q ∣ n := dvd_trans h7 h8
have ap_L : all_prime L := ndpl_L.left
define at ap_L
have q_prime_factor : prime_factor q n :=
And.intro (ap_L q q_in_L) q_dvd_n
show p ≤ q from p_least q q_prime_factor
done
done
· -- Proof of prod (p :: L) = n
rewrite [prod_cons, h6.right, n_eq_pm]
rfl
done
done
done
theorem Theorem_7_2_2 {a b c : Nat}
(h1 : c ∣ a * b) (h2 : rel_prime a c) : c ∣ b := by
rewrite [←Int.natCast_dvd_natCast] --Goal : ↑c ∣ ↑b
define at h1; define at h2; define
obtain (j : Nat) (h3 : a * b = c * j) from h1
set s : Int := gcd_c1 a c
set t : Int := gcd_c2 a c
have h4 : s * ↑a + t * ↑c = ↑(gcd a c) := gcd_lin_comb c a
rewrite [h2, Nat.cast_one] at h4 --h4 : s * ↑a + t * ↑c = (1 : Int)
apply Exists.intro (s * ↑j + t * ↑b)
show ↑b = ↑c * (s * ↑j + t * ↑b) from
calc ↑b
_ = (1 : Int) * ↑b := (one_mul _).symm
_ = (s * ↑a + t * ↑c) * ↑b := by rw [h4]
_ = s * (↑a * ↑b) + t * ↑c * ↑b := by ring
_ = s * (↑c * ↑j) + t * ↑c * ↑b := by
rw [←Nat.cast_mul a b, h3, Nat.cast_mul c j]
_ = ↑c * (s * ↑j + t * ↑b) := by ring
done
lemma le_nonzero_prod_left {a b : Nat} (h : a * b ≠ 0) : a ≤ a * b := by
have h1 : b ≠ 0 := by
contradict h with h1
rewrite [h1]
ring
done
have h2 : 1 ≤ b := Nat.pos_of_ne_zero h1
show a ≤ a * b from
calc a
= a * 1 := (mul_one a).symm
_ ≤ a * b := by rel [h2]
done
lemma le_nonzero_prod_right {a b : Nat} (h : a * b ≠ 0) : b ≤ a * b := by
rewrite [mul_comm]
rewrite [mul_comm] at h
show b ≤ b * a from le_nonzero_prod_left h
done
lemma dvd_prime {a p : Nat}
(h1 : prime p) (h2 : a ∣ p) : a = 1 ∨ a = p := sorry
lemma rel_prime_of_prime_not_dvd {a p : Nat}
(h1 : prime p) (h2 : ¬p ∣ a) : rel_prime a p := by
have h3 : gcd a p ∣ a := gcd_dvd_left a p
have h4 : gcd a p ∣ p := gcd_dvd_right a p
have h5 : gcd a p = 1 ∨ gcd a p = p := dvd_prime h1 h4
have h6 : gcd a p ≠ p := by
contradict h2 with h6
rewrite [h6] at h3
show p ∣ a from h3
done
disj_syll h5 h6
show rel_prime a p from h5
done
theorem Theorem_7_2_3 {a b p : Nat}
(h1 : prime p) (h2 : p ∣ a * b) : p ∣ a ∨ p ∣ b := by
or_right with h3
have h4 : rel_prime a p := rel_prime_of_prime_not_dvd h1 h3
show p ∣ b from Theorem_7_2_2 h2 h4
done
lemma ge_one_of_prod_one {a b : Nat} (h : a * b = 1) : a ≥ 1 := by
have h1 : a ≠ 0 := by
by_contra h1
rewrite [h1] at h
contradict h
linarith
done
show a ≥ 1 from Nat.pos_of_ne_zero h1
done
lemma eq_one_of_prod_one {a b : Nat} (h : a * b = 1) : a = 1 := by
have h1 : a ≥ 1 := ge_one_of_prod_one h
have h2 : a * b ≠ 0 := by linarith
have h3 : a ≤ a * b := le_nonzero_prod_left h2
rewrite [h] at h3
show a = 1 from Nat.le_antisymm h3 h1
done
lemma eq_one_of_dvd_one {n : Nat} (h : n ∣ 1) : n = 1 := by
obtain (j : Nat) (h1 : 1 = n * j) from h
show n = 1 from eq_one_of_prod_one h1.symm
done
lemma prime_not_one {p : Nat} (h : prime p) : p ≠ 1 := by
define at h
linarith
done
theorem Theorem_7_2_4 {p : Nat} (h1 : prime p) :
∀ (l : List Nat), p ∣ prod l → ∃ a ∈ l, p ∣ a := by
apply List.rec
· -- Base Case. Goal : p ∣ prod [] → ∃ a ∈ [], p ∣ a
rewrite [prod_nil]
assume h2 : p ∣ 1
show ∃ a ∈ [], p ∣ a from
absurd (eq_one_of_dvd_one h2) (prime_not_one h1)
done
· -- Induction Step
fix b : Nat
fix L : List Nat
assume ih : p ∣ prod L → ∃ a ∈ L, p ∣ a
--Goal : p ∣ prod (b :: L) → ∃ a ∈ b :: L, p ∣ a
assume h2 : p ∣ prod (b :: L)
rewrite [prod_cons] at h2
have h3 : p ∣ b ∨ p ∣ prod L := Theorem_7_2_3 h1 h2
by_cases on h3
· -- Case 1. h3 : p ∣ b
apply Exists.intro b
show b ∈ b :: L ∧ p ∣ b from
And.intro (List.mem_cons_self b L) h3
done
· -- Case 2. h3 : p ∣ prod L
obtain (a : Nat) (h4 : a ∈ L ∧ p ∣ a) from ih h3
apply Exists.intro a
show a ∈ b :: L ∧ p ∣ a from
And.intro (List.mem_cons_of_mem b h4.left) h4.right
done
done
done
lemma prime_in_list {p : Nat} {l : List Nat}
(h1 : prime p) (h2 : all_prime l) (h3 : p ∣ prod l) : p ∈ l := by
obtain (a : Nat) (h4 : a ∈ l ∧ p ∣ a) from Theorem_7_2_4 h1 l h3
define at h2
have h5 : prime a := h2 a h4.left
have h6 : p = 1 ∨ p = a := dvd_prime h5 h4.right
disj_syll h6 (prime_not_one h1)
rewrite [h6]
show a ∈ l from h4.left
done
lemma first_le_first {p q : Nat} {l m : List Nat}
(h1 : nondec_prime_list (p :: l)) (h2 : nondec_prime_list (q :: m))
(h3 : prod (p :: l) = prod (q :: m)) : p ≤ q := by
define at h1; define at h2
have h4 : q ∣ prod (p :: l) := by
define
apply Exists.intro (prod m)
rewrite [←prod_cons]
show prod (p :: l) = prod (q :: m) from h3
done
have h5 : all_prime (q :: m) := h2.left
rewrite [all_prime_cons] at h5
have h6 : q ∈ p :: l := prime_in_list h5.left h1.left h4
have h7 : nondec (p :: l) := h1.right
rewrite [nondec_cons] at h7
rewrite [List.mem_cons] at h6
by_cases on h6
· -- Case 1. h6 : q = p
linarith
done
· -- Case 2. h6 : q ∈ l
have h8 : ∀ m ∈ l, p ≤ m := h7.left
show p ≤ q from h8 q h6
done
done
lemma nondec_prime_list_tail {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : nondec_prime_list l := by
define at h
define
rewrite [all_prime_cons, nondec_cons] at h
show all_prime l ∧ nondec l from And.intro h.left.right h.right.right
done
lemma cons_prod_not_one {p : Nat} {l : List Nat}
(h : nondec_prime_list (p :: l)) : prod (p :: l) ≠ 1 := by
define at h
have h1 : all_prime (p :: l) := h.left
rewrite [all_prime_cons] at h1
rewrite [prod_cons]
by_contra h2
show False from (prime_not_one h1.left) (eq_one_of_prod_one h2)
done
lemma list_nil_iff_prod_one {l : List Nat} (h : nondec_prime_list l) :
l = [] ↔ prod l = 1 := by
apply Iff.intro
· -- (→)
assume h1 : l = []
rewrite [h1]
show prod [] = 1 from prod_nil
done
· -- (←)
contrapos
assume h1 : ¬l = []
obtain (p : Nat) (h2 : ∃ (L : List Nat), l = p :: L) from
List.exists_cons_of_ne_nil h1
obtain (L : List Nat) (h3 : l = p :: L) from h2
rewrite [h3] at h
rewrite [h3]
show ¬prod (p :: L) = 1 from cons_prod_not_one h
done
done
lemma prime_pos {p : Nat} (h : prime p) : p > 0 := by
define at h
linarith
done
theorem Theorem_7_2_5 : ∀ (l1 l2 : List Nat),
nondec_prime_list l1 → nondec_prime_list l2 →
prod l1 = prod l2 → l1 = l2 := by
apply List.rec
· -- Base Case. Goal : ∀ (l2 : List Nat), nondec_prime_list [] →
-- nondec_prime_list l2 → prod [] = prod l2 → [] = l2
fix l2 : List Nat
assume h1 : nondec_prime_list []
assume h2 : nondec_prime_list l2
assume h3 : prod [] = prod l2
rewrite [prod_nil, eq_comm, ←list_nil_iff_prod_one h2] at h3
show [] = l2 from h3.symm
done
· -- Induction Step
fix p : Nat
fix L1 : List Nat
assume ih : ∀ (L2 : List Nat), nondec_prime_list L1 →
nondec_prime_list L2 → prod L1 = prod L2 → L1 = L2
-- Goal : ∀ (l2 : List Nat), nondec_prime_list (p :: L1) →
-- nondec_prime_list l2 → prod (p :: L1) = prod l2 → p :: L1 = l2
fix l2 : List Nat
assume h1 : nondec_prime_list (p :: L1)
assume h2 : nondec_prime_list l2
assume h3 : prod (p :: L1) = prod l2
have h4 : ¬prod (p :: L1) = 1 := cons_prod_not_one h1
rewrite [h3, ←list_nil_iff_prod_one h2] at h4
obtain (q : Nat) (h5 : ∃ (L : List Nat), l2 = q :: L) from
List.exists_cons_of_ne_nil h4
obtain (L2 : List Nat) (h6 : l2 = q :: L2) from h5
rewrite [h6] at h2 --h2 : nondec_prime_list (q :: L2)
rewrite [h6] at h3 --h3 : prod (p :: L1) = prod (q :: L2)
have h7 : p ≤ q := first_le_first h1 h2 h3
have h8 : q ≤ p := first_le_first h2 h1 h3.symm
have h9 : p = q := by linarith
rewrite [h9, prod_cons, prod_cons] at h3
--h3 : q * prod L1 = q * prod L2
have h10 : nondec_prime_list L1 := nondec_prime_list_tail h1
have h11 : nondec_prime_list L2 := nondec_prime_list_tail h2
define at h2
have h12 : all_prime (q :: L2) := h2.left
rewrite [all_prime_cons] at h12
have h13 : q > 0 := prime_pos h12.left
have h14 : prod L1 = prod L2 := Nat.eq_of_mul_eq_mul_left h13 h3
have h15 : L1 = L2 := ih L2 h10 h11 h14
rewrite [h6, h9, h15]
rfl
done
done
theorem fund_thm_arith (n : Nat) (h : n ≥ 1) :
∃! (l : List Nat), prime_factorization n l := by
exists_unique
· -- Existence
show ∃ (l : List Nat), prime_factorization n l from
exists_prime_factorization n h
done
· -- Uniqueness
fix l1 : List Nat; fix l2 : List Nat
assume h1 : prime_factorization n l1
assume h2 : prime_factorization n l2
define at h1; define at h2
have h3 : prod l1 = n := h1.right
rewrite [←h2.right] at h3
show l1 = l2 from Theorem_7_2_5 l1 l2 h1.left h2.left h3
done
done
/- Section 7.3 -/
theorem congr_refl (m : Nat) : ∀ (a : Int), a ≡ a (MOD m) := by
fix a : Int
define --Goal : ∃ (c : Int), a - a = ↑m * c
apply Exists.intro 0
ring
done
theorem congr_symm {m : Nat} : ∀ {a b : Int},
a ≡ b (MOD m) → b ≡ a (MOD m) := by
fix a : Int; fix b : Int
assume h1 : a ≡ b (MOD m)
define at h1 --h1 : ∃ (c : Int), a - b = ↑m * c
define --Goal : ∃ (c : Int), b - a = ↑m * c
obtain (c : Int) (h2 : a - b = m * c) from h1
apply Exists.intro (-c)
show b - a = m * (-c) from
calc b - a
_ = -(a - b) := by ring
_ = -(m * c) := by rw [h2]
_ = m * (-c) := by ring
done
theorem congr_trans {m : Nat} : ∀ {a b c : Int},
a ≡ b (MOD m) → b ≡ c (MOD m) → a ≡ c (MOD m) := sorry
/- Fundamental properties of congruence classes -/
lemma cc_eq_iff_val_eq {n : Nat} (X Y : ZMod (n + 1)) :
X = Y ↔ X.val = Y.val := Fin.ext_iff
lemma val_nat_eq_mod (n k : Nat) :
([k]_(n + 1)).val = k % (n + 1) := by rfl
lemma val_zero (n : Nat) : ([0]_(n + 1)).val = 0 := by rfl
theorem cc_rep {m : Nat} (X : ZMod m) : ∃ (a : Int), X = [a]_m :=
match m with
| 0 => by
apply Exists.intro X
rfl
done
| n + 1 => by
apply Exists.intro ↑(X.val)
have h1 : X.val < n + 1 := Fin.prop X
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, Nat.mod_eq_of_lt h1]
rfl
done
theorem add_class (m : Nat) (a b : Int) :
[a]_m + [b]_m = [a + b]_m := (Int.cast_add a b).symm
theorem mul_class (m : Nat) (a b : Int) :
[a]_m * [b]_m = [a * b]_m := (Int.cast_mul a b).symm
lemma cc_eq_iff_sub_zero (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ [a - b]_m = [0]_m := by
apply Iff.intro
· -- (→)
assume h1 : [a]_m = [b]_m
have h2 : a - b = a + (-b) := by ring
have h3 : b + (-b) = 0 := by ring
show [a - b]_m = [0]_m from
calc [a - b]_m
_ = [a + (-b)]_m := by rw [h2]
_ = [a]_m + [-b]_m := by rw [add_class]
_ = [b]_m + [-b]_m := by rw [h1]
_ = [b + -b]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
· -- (←)
assume h1 : [a - b]_m = [0]_m
have h2 : b + (a - b) = a := by ring
have h3 : b + 0 = b := by ring
show [a]_m = [b]_m from
calc [a]_m
_ = [b + (a - b)]_m := by rw [h2]
_ = [b]_m + [a - b]_m := by rw [add_class]
_ = [b]_m + [0]_m := by rw [h1]
_ = [b + 0]_m := by rw [add_class]
_ = [b]_m := by rw [h3]
done
done
lemma cc_neg_zero_of_cc_zero (m : Nat) (a : Int) :
[a]_m = [0]_m → [-a]_m = [0]_m := by
assume h1 : [a]_m = [0]_m
have h2 : 0 + (-a) = -a := by ring
have h3 : a + (-a) = 0 := by ring
show [-a]_m = [0]_m from
calc [-a]_m
_ = [0 + (-a)]_m := by rw [h2]
_ = [0]_m + [-a]_m := by rw [add_class]
_ = [a]_m + [-a]_m := by rw [h1]
_ = [a + (-a)]_m := by rw [add_class]
_ = [0]_m := by rw [h3]
done
lemma cc_neg_zero_iff_cc_zero (m : Nat) (a : Int) :
[-a]_m = [0]_m ↔ [a]_m = [0]_m := by
apply Iff.intro _ (cc_neg_zero_of_cc_zero m a)
assume h1 : [-a]_m = [0]_m
have h2 : [-(-a)]_m = [0]_m := cc_neg_zero_of_cc_zero m (-a) h1
have h3 : -(-a) = a := by ring
rewrite [h3] at h2
show [a]_m = [0]_m from h2
done
lemma cc_mod_0 (a : Int) : [a]_0 = a := by rfl
lemma cc_nat_zero_iff_dvd (m k : Nat) : [k]_m = [0]_m ↔ m ∣ k :=
match m with
| 0 => by
have h : (0 : Int) = (↑(0 : Nat) : Int) := by rfl
rewrite [cc_mod_0, cc_mod_0, h, Nat.cast_inj]
apply Iff.intro
· -- (→)
assume h1 : k = 0
rewrite [h1]
show 0 ∣ 0 from dvd_self 0
done
· -- (←)
assume h1 : 0 ∣ k
obtain (c : Nat) (h2 : k = 0 * c) from h1
rewrite [h2]
ring
done
done
| n + 1 => by
rewrite [cc_eq_iff_val_eq, val_nat_eq_mod, val_zero]
show k % (n + 1) = 0 ↔ n + 1 ∣ k from
(Nat.dvd_iff_mod_eq_zero (n + 1) k).symm
done
lemma cc_zero_iff_dvd (m : Nat) (a : Int) : [a]_m = [0]_m ↔ ↑m ∣ a := by
obtain (k : Nat) (h1 : a = ↑k ∨ a = -↑k) from Int.eq_nat_or_neg a
by_cases on h1
· -- Case 1. h1: a = ↑k
rewrite [h1, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
· -- Case 2. h1: a = -↑k
rewrite [h1, cc_neg_zero_iff_cc_zero, Int.dvd_neg, Int.natCast_dvd_natCast]
show [↑k]_m = [0]_m ↔ m ∣ k from cc_nat_zero_iff_dvd m k
done
done
theorem cc_eq_iff_congr (m : Nat) (a b : Int) :
[a]_m = [b]_m ↔ a ≡ b (MOD m) :=
calc [a]_m = [b]_m
_ ↔ [a - b]_m = [0]_m := cc_eq_iff_sub_zero m a b
_ ↔ ↑m ∣ (a - b) := cc_zero_iff_dvd m (a - b)
_ ↔ a ≡ b (MOD m) := by rfl
/- End of fundamental properties of congruence classes -/
lemma mod_nonneg (m : Nat) [NeZero m] (a : Int) : 0 ≤ a % m := by
have h1 : (↑m : Int) ≠ 0 := (Nat.cast_ne_zero).rtl (NeZero.ne m)
show 0 ≤ a % m from Int.emod_nonneg a h1
done
lemma mod_lt (m : Nat) [NeZero m] (a : Int) : a % m < m := by
have h1 : m > 0 := Nat.pos_of_ne_zero (NeZero.ne m)
have h2 : (↑m : Int) > 0 := (Nat.cast_pos).rtl h1
show a % m < m from Int.emod_lt_of_pos a h2
done
lemma congr_mod_mod (m : Nat) (a : Int) : a ≡ a % m (MOD m) := by
define
have h1 : m * (a / m) + a % m = a := Int.ediv_add_emod a m
apply Exists.intro (a / m)
show a - a % m = m * (a / m) from
calc a - (a % m)
_ = m * (a / m) + a % m - a % m := by rw [h1]
_ = m * (a / m) := by ring
done
lemma mod_cmpl_res (m : Nat) [NeZero m] (a : Int) :
0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) :=
And.intro (mod_nonneg m a) (And.intro (mod_lt m a) (congr_mod_mod m a))
theorem Theorem_7_3_1 (m : Nat) [NeZero m] (a : Int) :
∃! (r : Int), 0 ≤ r ∧ r < m ∧ a ≡ r (MOD m) := by
exists_unique
· -- Existence
apply Exists.intro (a % m)
show 0 ≤ a % m ∧ a % m < m ∧ a ≡ a % m (MOD m) from
mod_cmpl_res m a
done
· -- Uniqueness
fix r1 : Int; fix r2 : Int
assume h1 : 0 ≤ r1 ∧ r1 < m ∧ a ≡ r1 (MOD m)
assume h2 : 0 ≤ r2 ∧ r2 < m ∧ a ≡ r2 (MOD m)
have h3 : r1 ≡ r2 (MOD m) :=
congr_trans (congr_symm h1.right.right) h2.right.right
obtain (d : Int) (h4 : r1 - r2 = m * d) from h3
have h5 : r1 - r2 < m * 1 := by linarith
have h6 : m * (-1) < r1 - r2 := by linarith
rewrite [h4] at h5 --h5 : m * d < m * 1
rewrite [h4] at h6 --h6 : m * -1 < m * d
have h7 : (↑m : Int) ≥ 0 := Nat.cast_nonneg m
have h8 : d < 1 := lt_of_mul_lt_mul_of_nonneg_left h5 h7
have h9 : -1 < d := lt_of_mul_lt_mul_of_nonneg_left h6 h7
have h10 : d = 0 := by linarith
show r1 = r2 from
calc r1
_ = r1 - r2 + r2 := by ring
_ = m * 0 + r2 := by rw [h4, h10]
_ = r2 := by ring
done
done
lemma cc_eq_mod (m : Nat) (a : Int) : [a]_m = [a % m]_m :=
(cc_eq_iff_congr m a (a % m)).rtl (congr_mod_mod m a)
theorem Theorem_7_3_6_1 {m : Nat} (X Y : ZMod m) : X + Y = Y + X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
obtain (b : Int) (h2 : Y = [b]_m) from cc_rep Y
rewrite [h1, h2]
have h3 : a + b = b + a := by ring
show [a]_m + [b]_m = [b]_m + [a]_m from
calc [a]_m + [b]_m
_ = [a + b]_m := add_class m a b
_ = [b + a]_m := by rw [h3]
_ = [b]_m + [a]_m := (add_class m b a).symm
done
theorem Theorem_7_3_6_7 {m : Nat} (X : ZMod m) : X * [1]_m = X := by
obtain (a : Int) (h1 : X = [a]_m) from cc_rep X
rewrite [h1]
have h2 : a * 1 = a := by ring
show [a]_m * [1]_m = [a]_m from
calc [a]_m * [1]_m
_ = [a * 1]_m := mul_class m a 1
_ = [a]_m := by rw [h2]
done
theorem Exercise_7_2_6 (a b : Nat) :
rel_prime a b ↔ ∃ (s t : Int), s * a + t * b = 1 := sorry
lemma gcd_c2_inv {m a : Nat} (h1 : rel_prime m a) :
[a]_m * [gcd_c2 m a]_m = [1]_m := by
set s : Int := gcd_c1 m a
have h2 : s * m + (gcd_c2 m a) * a = gcd m a := gcd_lin_comb a m
define at h1
rewrite [h1, Nat.cast_one] at h2 --h2 : s * ↑m + gcd_c2 m a * ↑a = 1
rewrite [mul_class, cc_eq_iff_congr]
define --Goal : ∃ (c : Int), ↑a * gcd_c2 m a - 1 = ↑m * c
apply Exists.intro (-s)
show a * (gcd_c2 m a) - 1 = m * (-s) from
calc a * (gcd_c2 m a) - 1
_ = s * m + (gcd_c2 m a) * a + m * (-s) - 1 := by ring
_ = 1 + m * (-s) - 1 := by rw [h2]
_ = m * (-s) := by ring
done
theorem Theorem_7_3_7 (m a : Nat) :
invertible [a]_m ↔ rel_prime m a := by
apply Iff.intro
· -- (→)
assume h1 : invertible [a]_m
define at h1
obtain (Y : ZMod m) (h2 : [a]_m * Y = [1]_m) from h1
obtain (b : Int) (h3 : Y = [b]_m) from cc_rep Y
rewrite [h3, mul_class, cc_eq_iff_congr] at h2
define at h2
obtain (c : Int) (h4 : a * b - 1 = m * c) from h2
rewrite [Exercise_7_2_6]
--Goal : ∃ (s t : Int), s * ↑m + t * ↑a = 1
apply Exists.intro (-c)
apply Exists.intro b
show (-c) * m + b * a = 1 from
calc (-c) * m + b * a
_ = (-c) * m + (a * b - 1) + 1 := by ring
_ = (-c) * m + m * c + 1 := by rw [h4]
_ = 1 := by ring
done
· -- (←)
assume h1 : rel_prime m a
define
show ∃ (Y : ZMod m), [a]_m * Y = [1]_m from
Exists.intro [gcd_c2 m a]_m (gcd_c2_inv h1)
done
done
/- Section 7.4 -/
section Euler
open Euler
lemma num_rp_below_base {m : Nat} :
num_rp_below m 0 = 0 := by rfl
lemma num_rp_below_step_rp {m j : Nat} (h : rel_prime m j) :
num_rp_below m (j + 1) = (num_rp_below m j) + 1 := by
have h1 : num_rp_below m (j + 1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : gcd m j = 1
rewrite [if_pos h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j + 1
show num_rp_below m (j + 1) = num_rp_below m j + 1 from h1
done
lemma num_rp_below_step_not_rp {m j : Nat} (h : ¬rel_prime m j) :
num_rp_below m (j + 1) = num_rp_below m j := by
have h1 : num_rp_below m (j +1) =
if gcd m j = 1 then (num_rp_below m j) + 1
else num_rp_below m j := by rfl
define at h --h : ¬gcd m j = 1
rewrite [if_neg h] at h1
--h1 : num_rp_below m (j + 1) = num_rp_below m j
show num_rp_below m (j + 1) = num_rp_below m j from h1
done
lemma phi_def (m : Nat) : phi m = num_rp_below m m := by rfl
#eval phi 10 --Answer: 4
lemma prod_inv_iff_inv {m : Nat} {X : ZMod m}
(h1 : invertible X) (Y : ZMod m) :
invertible (X * Y) ↔ invertible Y := by
apply Iff.intro
· -- (→)
assume h2 : invertible (X * Y)
obtain (Z : ZMod m) (h3 : X * Y * Z = [1]_m) from h2
apply Exists.intro (X * Z)
rewrite [←h3] --Goal : Y * (X * Z) = X * Y * Z
ring --Note that ring can do algebra in ZMod m
done
· -- (←)
assume h2 : invertible Y
obtain (Xi : ZMod m) (h3 : X * Xi = [1]_m) from h1
obtain (Yi : ZMod m) (h4 : Y * Yi = [1]_m) from h2
apply Exists.intro (Xi * Yi)
show (X * Y) * (Xi * Yi) = [1]_m from
calc X * Y * (Xi * Yi)
_ = (X * Xi) * (Y * Yi) := by ring
_ = [1]_m * [1]_m := by rw [h3, h4]
_ = [1]_m := Theorem_7_3_6_7 [1]_m
done
done
lemma F_rp_def {m i : Nat} (h : rel_prime m i) :
F m i = [i]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h --h : gcd m i = 1
rewrite [if_pos h] at h1
show F m i = [i]_m from h1
done
lemma F_not_rp_def {m i : Nat} (h : ¬rel_prime m i) :
F m i = [1]_m := by
have h1 : F m i = if gcd m i = 1 then [i]_m else [1]_m := by rfl
define at h
rewrite [h1, if_neg h]
rfl
done
lemma prod_seq_base {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 0 k f = [1]_m := by rfl
lemma prod_seq_step {m : Nat}
(n k : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) k f = prod_seq n k f * f (k + n) := by rfl
lemma prod_seq_zero_step {m : Nat}
(n : Nat) (f : Nat → ZMod m) :
prod_seq (n + 1) 0 f = prod_seq n 0 f * f n := by
rewrite [prod_seq_step, zero_add]
rfl
done
lemma prod_one {m : Nat}
(k : Nat) (f : Nat → ZMod m) : prod_seq 1 k f = f k := by
rewrite [prod_seq_step, prod_seq_base, add_zero, mul_comm, Theorem_7_3_6_7]
rfl
done
lemma G_def (m a i : Nat) : G m a i = (a * i) % m := by rfl
lemma cc_G (m a i : Nat) : [G m a i]_m = [a]_m * [i]_m :=
calc [G m a i]_m
_ = [(a * i) % m]_m := by rfl
_ = [a * i]_m := (cc_eq_mod m (a * i)).symm
_ = [a]_m * [i]_m := (mul_class m a i).symm
lemma G_rp_iff {m a : Nat} (h1 : rel_prime m a) (i : Nat) :
rel_prime m (G m a i) ↔ rel_prime m i := by
have h2 : invertible [a]_m := (Theorem_7_3_7 m a).rtl h1
show rel_prime m (G m a i) ↔ rel_prime m i from
calc rel_prime m (G m a i)
_ ↔ invertible [G m a i]_m := (Theorem_7_3_7 m (G m a i)).symm
_ ↔ invertible ([a]_m * [i]_m) := by rw [cc_G]
_ ↔ invertible [i]_m := prod_inv_iff_inv h2 ([i]_m)
_ ↔ rel_prime m i := Theorem_7_3_7 m i
done
lemma FG_rp {m a i : Nat} (h1 : rel_prime m a) (h2 : rel_prime m i) :
F m (G m a i) = [a]_m * F m i := by
have h3 : rel_prime m (G m a i) := (G_rp_iff h1 i).rtl h2
show F m (G m a i) = [a]_m * F m i from
calc F m (G m a i)
_ = [G m a i]_m := F_rp_def h3
_ = [a]_m * [i]_m := cc_G m a i
_ = [a]_m * F m i := by rw [F_rp_def h2]
done
lemma FG_not_rp {m a i : Nat} (h1 : rel_prime m a) (h2 : ¬rel_prime m i) :
F m (G m a i) = [1]_m := by
rewrite [←G_rp_iff h1 i] at h2
show F m (G m a i) = [1]_m from F_not_rp_def h2
done
lemma FG_prod {m a : Nat} (h1 : rel_prime m a) :
∀ (k : Nat), prod_seq k 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) := by
by_induc
· -- Base Case
show prod_seq 0 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m 0) * prod_seq 0 0 (F m) from
calc prod_seq 0 0 ((F m) ∘ (G m a))
_ = [1]_m := prod_seq_base _ _
_ = [a]_m ^ 0 * [1]_m := by ring
_ = [a]_m ^ (num_rp_below m 0) * prod_seq 0 0 (F m) := by
rw [num_rp_below_base, prod_seq_base]
done
· -- Induction Step
fix k : Nat
assume ih : prod_seq k 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m)
by_cases h2 : rel_prime m k
· -- Case 1. h2 : rel_prime m k
show prod_seq (k + 1) 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) from
calc prod_seq (k + 1) 0 ((F m) ∘ (G m a))
_ = prod_seq k 0 ((F m) ∘ (G m a)) *
F m (G m a k) := prod_seq_zero_step _ _
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
F m (G m a k) := by rw [ih]
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
([a]_m * F m k) := by rw [FG_rp h1 h2]
_ = [a]_m ^ ((num_rp_below m k) + 1) *
((prod_seq k 0 (F m)) * F m k) := by ring
_ = [a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) := by
rw [num_rp_below_step_rp h2, prod_seq_zero_step]
done
· -- Case 2. h2 : ¬rel_prime m k
show prod_seq (k + 1) 0 ((F m) ∘ (G m a)) =
[a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) from
calc prod_seq (k + 1) 0 ((F m) ∘ (G m a))
_ = prod_seq k 0 ((F m) ∘ (G m a)) *
F m (G m a k) := prod_seq_zero_step _ _
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
F m (G m a k) := by rw [ih]
_ = [a]_m ^ (num_rp_below m k) * prod_seq k 0 (F m) *
([1]_m) := by rw [FG_not_rp h1 h2]
_ = [a]_m ^ (num_rp_below m k) *
(prod_seq k 0 (F m) * ([1]_m)) := by ring
_ = [a]_m ^ (num_rp_below m (k + 1)) *
prod_seq (k + 1) 0 (F m) := by
rw [num_rp_below_step_not_rp h2, prod_seq_zero_step,
F_not_rp_def h2]
done
done
done
lemma G_maps_below (m a : Nat) [NeZero m] : maps_below m (G m a) := by
define --Goal : ∀ i < m, G m a i < m
fix i : Nat
assume h1 : i < m
rewrite [G_def] --Goal : a * i % m < m
show a * i % m < m from mod_nonzero_lt (a * i) (NeZero.ne m)
done
lemma left_inv_one_one_below {n : Nat} {g g' : Nat → Nat}
(h1 : ∀ i < n, g' (g i) = i) : one_one_below n g := sorry
lemma right_inv_onto_below {n : Nat} {g g' : Nat → Nat}
(h1 : ∀ i < n, g (g' i) = i) (h2 : maps_below n g') :
onto_below n g := by
define at h2; define
fix k : Nat
assume h3 : k < n
apply Exists.intro (g' k)
show g' k < n ∧ g (g' k) = k from And.intro (h2 k h3) (h1 k h3)
done
lemma cc_mul_inv_mod_eq_one {m a : Nat} [NeZero m] (h1 : rel_prime m a) :
[a]_m * [inv_mod m a]_m = [1]_m := by
have h2 : 0 ≤ (gcd_c2 m a) % m := mod_nonneg m (gcd_c2 m a)
show [a]_m * [inv_mod m a]_m = [1]_m from
calc [a]_m * [inv_mod m a]_m
_ = [a]_m * [Int.toNat ((gcd_c2 m a) % m)]_m := by rfl
_ = [a]_m * [(gcd_c2 m a) % m]_m := by rw [Int.toNat_of_nonneg h2]
_ = [a]_m * [gcd_c2 m a]_m := by rw [←cc_eq_mod]
_ = [1]_m := gcd_c2_inv h1
done
lemma mul_mod_mod_eq_mul_mod (m a b : Nat) : (a * (b % m)) % m = (a * b) % m :=
calc a * (b % m) % m
= a % m * (b % m % m) % m := Nat.mul_mod _ _ _
_ = a % m * (b % m) % m := by rw [Nat.mod_mod]
_ = a * b % m := (Nat.mul_mod _ _ _).symm
lemma mod_mul_mod_eq_mul_mod (m a b : Nat) : (a % m * b) % m = (a * b) % m := by
rewrite [mul_comm, mul_mod_mod_eq_mul_mod, mul_comm]
rfl
done
theorem congr_iff_mod_eq_Nat (m a b : Nat) [NeZero m] :
↑a ≡ ↑b (MOD m) ↔ a % m = b % m := sorry
| lemma mul_inv_mod_cancel {m a i : Nat} [NeZero m]
(h1 : rel_prime m a) (h2 : i < m) : a * (inv_mod m a) * i % m = i | HTPI.mul_inv_mod_cancel | null | null | htpi/HTPILib/Chap7.lean | {
"lineInFile": 1309,
"tokenPositionInFile": 42213,
"theoremPositionInFile": 123
} | {
"inFilePremises": true,
"repositoryPremises": true
} | {
"hasProof": true,
"proof": ":= by\n have h3 : [a]_m * [inv_mod m a]_m = [1]_m := cc_mul_inv_mod_eq_one h1\n rewrite [mul_class, cc_eq_iff_congr, ←Nat.cast_mul, ←Nat.cast_one, congr_iff_mod_eq_Nat] at h3\n show a * inv_mod m a * i % m = i from\n calc a * (inv_mod m a) * i % m\n _ = (a * inv_mod m a) % m * i % m := by rw [mod_mul_mod_eq_mul_mod]\n _ = 1 % m * i % m := by rw [h3]\n _ = 1 * i % m := by rw [mod_mul_mod_eq_mul_mod]\n _ = i % m := by rw [one_mul]\n _ = i := Nat.mod_eq_of_lt h2\n done",
"proofType": "tactic",
"proofLengthLines": 10,
"proofLengthTokens": 492
} | htpi |