Documentation

🔹 coverage

def Nat.ModEq (n a b : ℕ) :

Prop

Modular equality. n.ModEq a b, or a ≡ b [MOD n], means that a % n = b % n.

Instances For

def «term_≡_[MOD_]» :

Lean.TrailingParserDescr

Modular equality. n.ModEq a b, or a ≡ b [MOD n], means that a % n = b % n.

Instances For

@[simp]

theorem AddCommGroup.modEq_iff_natModEq {a b n : ℕ} :

a ≡ b [PMOD n] ↔ a ≡ b [MOD n]

theorem AddCommGroup.ModEq.natCast {M : Type u_1} [AddCommMonoidWithOne M] {a b n : ℕ} (h : a ≡ b [MOD n]) :

↑a ≡ ↑b [PMOD ↑n]

@[simp]

theorem AddCommGroup.natCast_modEq_natCast {M : Type u_1} [AddCommMonoidWithOne M] [CharZero M] {a b n : ℕ} :

↑a ≡ ↑b [PMOD ↑n] ↔ a ≡ b [MOD n]

theorem Nat.ModEq.of_natCast {M : Type u_1} [AddCommMonoidWithOne M] [CharZero M] {a b n : ℕ} :

↑a ≡ ↑b [PMOD ↑n] → a ≡ b [MOD n]

Alias of the forward direction of AddCommGroup.natCast_modEq_natCast.

@[implicit_reducible]

instance Nat.instDecidableModEq {n a b : ℕ} :

Decidable (a ≡ b [MOD n])

theorem Nat.ModEq.refl {n : ℕ} (a : ℕ) :

a ≡ a [MOD n]

theorem Nat.ModEq.rfl {n a : ℕ} :

a ≡ a [MOD n]

instance Nat.ModEq.instRefl {n : ℕ} :

Std.Refl n.ModEq

theorem Nat.ModEq.symm {n a b : ℕ} :

a ≡ b [MOD n] → b ≡ a [MOD n]

theorem Nat.ModEq.trans {n a b c : ℕ} :

a ≡ b [MOD n] → b ≡ c [MOD n] → a ≡ c [MOD n]

@[implicit_reducible]

instance Nat.ModEq.instTrans {n : ℕ} :

Trans n.ModEq n.ModEq n.ModEq

theorem Nat.ModEq.comm {n a b : ℕ} :

a ≡ b [MOD n] ↔ b ≡ a [MOD n]

theorem Nat.modEq_zero_iff_dvd {n a : ℕ} :

a ≡ 0 [MOD n] ↔ n ∣ a

theorem Dvd.dvd.modEq_zero_nat {n a : ℕ} (h : n ∣ a) :

a ≡ 0 [MOD n]

theorem Dvd.dvd.zero_modEq_nat {n a : ℕ} (h : n ∣ a) :

0 ≡ a [MOD n]

theorem Nat.modEq_iff_dvd {n a b : ℕ} :

a ≡ b [MOD n] ↔ ↑n ∣ ↑b - ↑a

theorem Nat.ModEq.dvd {n a b : ℕ} :

a ≡ b [MOD n] → ↑n ∣ ↑b - ↑a

Alias of the forward direction of Nat.modEq_iff_dvd.

theorem Nat.modEq_of_dvd {n a b : ℕ} :

↑n ∣ ↑b - ↑a → a ≡ b [MOD n]

Alias of the reverse direction of Nat.modEq_iff_dvd.

theorem Nat.modEq_iff_dvd' {n a b : ℕ} (h : a ≤ b) :

a ≡ b [MOD n] ↔ n ∣ b - a

A variant of modEq_iff_dvd with Nat divisibility

theorem Nat.mod_modEq (a n : ℕ) :

a % n ≡ a [MOD n]

theorem Nat.ModEq.modulus_mul_add {m a b : ℕ} :

m * a + b ≡ b [MOD m]

@[deprecated Nat.ModEq.modulus_mul_add (since := "2025-10-16")]

theorem Nat.ModEq.self_mul_add {m a b : ℕ} :

m * a + b ≡ b [MOD m]

Alias of Nat.ModEq.modulus_mul_add.

theorem Nat.ModEq.of_dvd {m n a b : ℕ} (d : m ∣ n) (h : a ≡ b [MOD n]) :

a ≡ b [MOD m]

theorem Nat.ModEq.mul_left' {n a b : ℕ} (c : ℕ) (h : a ≡ b [MOD n]) :

c * a ≡ c * b [MOD c * n]

theorem Nat.ModEq.mul_left {n a b : ℕ} (c : ℕ) (h : a ≡ b [MOD n]) :

c * a ≡ c * b [MOD n]

theorem Nat.ModEq.mul_right' {n a b : ℕ} (c : ℕ) (h : a ≡ b [MOD n]) :

a * c ≡ b * c [MOD n * c]

theorem Nat.ModEq.mul_right {n a b : ℕ} (c : ℕ) (h : a ≡ b [MOD n]) :

a * c ≡ b * c [MOD n]

theorem Nat.ModEq.mul {n a b c d : ℕ} (h₁ : a ≡ b [MOD n]) (h₂ : c ≡ d [MOD n]) :

a * c ≡ b * d [MOD n]

theorem Nat.ModEq.pow {n a b : ℕ} (m : ℕ) (h : a ≡ b [MOD n]) :

a ^ m ≡ b ^ m [MOD n]

theorem Nat.ModEq.add {n a b c d : ℕ} (h₁ : a ≡ b [MOD n]) (h₂ : c ≡ d [MOD n]) :

a + c ≡ b + d [MOD n]

theorem Nat.ModEq.add_left {n a b : ℕ} (c : ℕ) (h : a ≡ b [MOD n]) :

c + a ≡ c + b [MOD n]

theorem Nat.ModEq.add_right {n a b : ℕ} (c : ℕ) (h : a ≡ b [MOD n]) :

a + c ≡ b + c [MOD n]

theorem Nat.ModEq.add_left_cancel {n a b c d : ℕ} (h₁ : a ≡ b [MOD n]) (h₂ : a + c ≡ b + d [MOD n]) :

c ≡ d [MOD n]

theorem Nat.ModEq.add_left_cancel' {n a b : ℕ} (c : ℕ) (h : c + a ≡ c + b [MOD n]) :

a ≡ b [MOD n]

@[simp]

theorem Nat.ModEq.add_iff_left {n a b c d : ℕ} (h : a ≡ b [MOD n]) :

a + c ≡ b + d [MOD n] ↔ c ≡ d [MOD n]

theorem Nat.ModEq.add_right_cancel {n a b c d : ℕ} (h₁ : c ≡ d [MOD n]) (h₂ : a + c ≡ b + d [MOD n]) :

a ≡ b [MOD n]

theorem Nat.ModEq.add_right_cancel' {n a b : ℕ} (c : ℕ) (h : a + c ≡ b + c [MOD n]) :

a ≡ b [MOD n]

@[simp]

theorem Nat.ModEq.add_iff_right {n a b c d : ℕ} (h : c ≡ d [MOD n]) :

a + c ≡ b + d [MOD n] ↔ a ≡ b [MOD n]

theorem Nat.ModEq.sub' {n a b c d : ℕ} (h : c ≤ a ↔ d ≤ b) (hab : a ≡ b [MOD n]) (hcd : c ≡ d [MOD n]) :

a - c ≡ b - d [MOD n]

theorem Nat.ModEq.sub_left' {n a b c : ℕ} (h : b ≤ a ↔ c ≤ a) (hbc : b ≡ c [MOD n]) :

a - b ≡ a - c [MOD n]

theorem Nat.ModEq.sub_right' {n a b c : ℕ} (h : a ≤ b ↔ a ≤ c) (hbc : b ≡ c [MOD n]) :

b - a ≡ c - a [MOD n]

theorem Nat.ModEq.sub {n a b c d : ℕ} (hca : c ≤ a) (hdb : d ≤ b) (hab : a ≡ b [MOD n]) (hcd : c ≡ d [MOD n]) :

a - c ≡ b - d [MOD n]

theorem Nat.ModEq.sub_left {n a b c : ℕ} (hba : b ≤ a) (hca : c ≤ a) (hbc : b ≡ c [MOD n]) :

a - b ≡ a - c [MOD n]

theorem Nat.ModEq.sub_right {n a b c : ℕ} (hab : a ≤ b) (hac : a ≤ c) (hbc : b ≡ c [MOD n]) :

b - a ≡ c - a [MOD n]

theorem Nat.ModEq.mul_left_cancel' {a b c m : ℕ} (hc : c ≠ 0) :

c * a ≡ c * b [MOD c * m] → a ≡ b [MOD m]

Cancel left multiplication on both sides of the ≡ and in the modulus.

For cancelling left multiplication in the modulus, see Nat.ModEq.of_mul_left.

theorem Nat.ModEq.mul_left_cancel_iff' {a b c m : ℕ} (hc : c ≠ 0) :

c * a ≡ c * b [MOD c * m] ↔ a ≡ b [MOD m]

theorem Nat.ModEq.mul_right_cancel' {a b c m : ℕ} (hc : c ≠ 0) :

a * c ≡ b * c [MOD m * c] → a ≡ b [MOD m]

Cancel right multiplication on both sides of the ≡ and in the modulus.

For cancelling right multiplication in the modulus, see Nat.ModEq.of_mul_right.

theorem Nat.ModEq.mul_right_cancel_iff' {a b c m : ℕ} (hc : c ≠ 0) :

a * c ≡ b * c [MOD m * c] ↔ a ≡ b [MOD m]

theorem Nat.ModEq.of_mul_left {n a b : ℕ} (m : ℕ) (h : a ≡ b [MOD m * n]) :

a ≡ b [MOD n]

Cancel left multiplication in the modulus.

For cancelling left multiplication on both sides of the ≡, see nat.modeq.mul_left_cancel'.

theorem Nat.ModEq.of_mul_right {n a b : ℕ} (m : ℕ) :

a ≡ b [MOD n * m] → a ≡ b [MOD n]

Cancel right multiplication in the modulus.

For cancelling right multiplication on both sides of the ≡, see nat.modeq.mul_right_cancel'.

theorem Nat.ModEq.of_div {m a b c : ℕ} (h : a / c ≡ b / c [MOD m / c]) (ha : c ∣ a) :

c ∣ b → c ∣ m → a ≡ b [MOD m]

@[simp]

theorem Nat.modulus_modEq_zero {n : ℕ} :

n ≡ 0 [MOD n]

@[simp]

theorem Nat.add_modEq_left_iff {n a b : ℕ} :

a + b ≡ a [MOD n] ↔ n ∣ b

@[simp]

theorem Nat.add_modEq_right_iff {n a b : ℕ} :

a + b ≡ b [MOD n] ↔ n ∣ a

@[simp]

theorem Nat.left_modEq_add_iff {n a b : ℕ} :

a ≡ a + b [MOD n] ↔ n ∣ b

@[simp]

theorem Nat.right_modEq_add_iff {n a b : ℕ} :

b ≡ a + b [MOD n] ↔ n ∣ a

@[simp]

theorem Nat.add_modulus_modEq_iff {n a b : ℕ} :

a + n ≡ b [MOD n] ↔ a ≡ b [MOD n]

@[simp]

theorem Nat.modulus_add_modEq_iff {n a b : ℕ} :

n + a ≡ b [MOD n] ↔ a ≡ b [MOD n]

@[simp]

theorem Nat.modEq_add_modulus_iff {n a b : ℕ} :

a ≡ b + n [MOD n] ↔ a ≡ b [MOD n]

@[simp]

theorem Nat.modEq_modulus_add_iff {n a b : ℕ} :

a ≡ n + b [MOD n] ↔ a ≡ b [MOD n]

@[simp]

theorem Nat.add_mul_modulus_modEq_iff {n a b c : ℕ} :

a + b * n ≡ c [MOD n] ↔ a ≡ c [MOD n]

@[simp]

theorem Nat.mul_modulus_add_modEq_iff {n a b c : ℕ} :

b * n + a ≡ c [MOD n] ↔ a ≡ c [MOD n]

@[simp]

theorem Nat.modEq_add_mul_modulus_iff {n a b c : ℕ} :

a ≡ b + c * n [MOD n] ↔ a ≡ b [MOD n]

@[simp]

theorem Nat.modEq_mul_modulus_add_iff {n a b c : ℕ} :

a ≡ b * n + c [MOD n] ↔ a ≡ c [MOD n]

@[simp]

theorem Nat.add_modulus_mul_modEq_iff {n a b c : ℕ} :

a + n * b ≡ c [MOD n] ↔ a ≡ c [MOD n]

@[simp]

theorem Nat.modulus_mul_add_modEq_iff {n a b c : ℕ} :

n * b + a ≡ c [MOD n] ↔ a ≡ c [MOD n]

@[simp]

theorem Nat.modEq_add_modulus_mul_iff {n a b c : ℕ} :

a ≡ b + n * c [MOD n] ↔ a ≡ b [MOD n]

@[simp]

theorem Nat.modEq_modulus_mul_add_iff {n a b c : ℕ} :

a ≡ n * b + c [MOD n] ↔ a ≡ c [MOD n]

@[simp]

theorem Nat.sub_modulus_modEq_iff {n a b : ℕ} (h : n ≤ a) :

a - n ≡ b [MOD n] ↔ a ≡ b [MOD n]

@[simp]

theorem Nat.modEq_sub_modulus_iff {n a b : ℕ} (h : n ≤ b) :

a ≡ b - n [MOD n] ↔ a ≡ b [MOD n]

theorem Nat.modEq_sub {a b : ℕ} (h : b ≤ a) :

a ≡ b [MOD a - b]

theorem Nat.modEq_one {a b : ℕ} :

a ≡ b [MOD 1]

@[simp]

theorem Nat.modEq_zero_iff {a b : ℕ} :

a ≡ b [MOD 0] ↔ a = b

theorem Nat.add_modEq_left {n a : ℕ} :

n + a ≡ a [MOD n]

theorem Nat.add_modEq_right {n a : ℕ} :

a + n ≡ a [MOD n]

theorem Nat.modEq_iff_exists_eq_add {n a b : ℕ} (h : a ≤ b) :

a ≡ b [MOD n] ↔ ∃ (t : ℕ), b = a + n * t

theorem Nat.ModEq.le_of_lt_add {m a b : ℕ} (h1 : a ≡ b [MOD m]) (h2 : a < b + m) :

a ≤ b

theorem Nat.ModEq.add_le_of_lt {m a b : ℕ} (h1 : a ≡ b [MOD m]) (h2 : a < b) :

a + m ≤ b

theorem Nat.ModEq.dvd_iff {m a b d : ℕ} (h : a ≡ b [MOD m]) (hdm : d ∣ m) :

d ∣ a ↔ d ∣ b

theorem Nat.ModEq.gcd_eq {m a b : ℕ} (h : a ≡ b [MOD m]) :

a.gcd m = b.gcd m

theorem Nat.ModEq.eq_of_abs_lt {m a b : ℕ} (h : a ≡ b [MOD m]) (h2 : |↑b - ↑a| < ↑m) :

a = b

theorem Nat.ModEq.eq_of_lt_of_lt {m a b : ℕ} (h : a ≡ b [MOD m]) (ha : a < m) (hb : b < m) :

a = b

theorem Nat.ModEq.cancel_left_div_gcd {m a b c : ℕ} (hm : 0 < m) (h : c * a ≡ c * b [MOD m]) :

a ≡ b [MOD m / m.gcd c]

To cancel a common factor c from a ModEq we must divide the modulus m by gcd m c

theorem Nat.ModEq.cancel_right_div_gcd {m a b c : ℕ} (hm : 0 < m) (h : a * c ≡ b * c [MOD m]) :

a ≡ b [MOD m / m.gcd c]

To cancel a common factor c from a ModEq we must divide the modulus m by gcd m c

theorem Nat.ModEq.cancel_left_div_gcd' {m a b c d : ℕ} (hm : 0 < m) (hcd : c ≡ d [MOD m]) (h : c * a ≡ d * b [MOD m]) :

a ≡ b [MOD m / m.gcd c]

theorem Nat.ModEq.cancel_right_div_gcd' {m a b c d : ℕ} (hm : 0 < m) (hcd : c ≡ d [MOD m]) (h : a * c ≡ b * d [MOD m]) :

a ≡ b [MOD m / m.gcd c]

theorem Nat.ModEq.cancel_left_of_coprime {m a b c : ℕ} (hmc : m.gcd c = 1) (h : c * a ≡ c * b [MOD m]) :

a ≡ b [MOD m]

A common factor that's coprime with the modulus can be cancelled from a ModEq

theorem Nat.ModEq.cancel_right_of_coprime {m a b c : ℕ} (hmc : m.gcd c = 1) (h : a * c ≡ b * c [MOD m]) :

a ≡ b [MOD m]

A common factor that's coprime with the modulus can be cancelled from a ModEq

def Nat.chineseRemainder' {m n a b : ℕ} (h : a ≡ b [MOD n.gcd m]) :

{ k : ℕ // k ≡ a [MOD n] ∧ k ≡ b [MOD m] }

The natural number less than lcm n m congruent to a mod n and b mod m

Instances For

def Nat.chineseRemainder {m n : ℕ} (co : n.Coprime m) (a b : ℕ) :

{ k : ℕ // k ≡ a [MOD n] ∧ k ≡ b [MOD m] }

The natural number less than n*m congruent to a mod n and b mod m

Instances For

theorem Nat.chineseRemainder'_lt_lcm {m n a b : ℕ} (h : a ≡ b [MOD n.gcd m]) (hn : n ≠ 0) (hm : m ≠ 0) :

↑(chineseRemainder' h) < n.lcm m

theorem Nat.chineseRemainder_lt_mul {m n : ℕ} (co : n.Coprime m) (a b : ℕ) (hn : n ≠ 0) (hm : m ≠ 0) :

↑(chineseRemainder co a b) < n * m

theorem Nat.mod_lcm {m n a b : ℕ} (hn : a ≡ b [MOD n]) (hm : a ≡ b [MOD m]) :

a ≡ b [MOD n.lcm m]

theorem Nat.chineseRemainder_modEq_unique {m n : ℕ} (co : n.Coprime m) {a b z : ℕ} (hzan : z ≡ a [MOD n]) (hzbm : z ≡ b [MOD m]) :

z ≡ ↑(chineseRemainder co a b) [MOD n * m]

theorem Nat.modEq_and_modEq_iff_modEq_mul {a b m n : ℕ} (hmn : m.Coprime n) :

a ≡ b [MOD m] ∧ a ≡ b [MOD n] ↔ a ≡ b [MOD m * n]

theorem Nat.coprime_of_mul_modEq_one (b : ℕ) {a n : ℕ} (h : a * b ≡ 1 [MOD n]) :

a.Coprime n

theorem Nat.add_mod_add_ite (a b c : ℕ) :

((a + b) % c + if c ≤ a % c + b % c then c else 0) = a % c + b % c

theorem Nat.add_mod_of_add_mod_lt {a b c : ℕ} (hc : a % c + b % c < c) :

(a + b) % c = a % c + b % c

theorem Nat.add_mod_add_of_le_add_mod {a b c : ℕ} (hc : c ≤ a % c + b % c) :

(a + b) % c + c = a % c + b % c

theorem Nat.add_div_eq_of_add_mod_lt {a b c : ℕ} (hc : a % c + b % c < c) :

(a + b) / c = a / c + b / c

theorem Nat.add_div_of_dvd_right {a b c : ℕ} (hca : c ∣ a) :

(a + b) / c = a / c + b / c

theorem Nat.add_div_of_dvd_left {a b c : ℕ} (hca : c ∣ b) :

(a + b) / c = a / c + b / c

theorem Nat.add_div_eq_of_le_mod_add_mod {a b c : ℕ} (hc : c ≤ a % c + b % c) (hc0 : 0 < c) :

(a + b) / c = a / c + b / c + 1

theorem Nat.add_div_le_add_div (a b c : ℕ) :

a / c + b / c ≤ (a + b) / c

theorem Nat.le_mod_add_mod_of_dvd_add_of_not_dvd {a b c : ℕ} (h : c ∣ a + b) (ha : ¬c ∣ a) :

c ≤ a % c + b % c

theorem Nat.mod_sub_of_le {a b n : ℕ} (h : b ≤ a % n) :

a % n - b = (a - b) % n

theorem Nat.odd_mul_odd {n m : ℕ} :

n % 2 = 1 → m % 2 = 1 → n * m % 2 = 1

theorem Nat.odd_mul_odd_div_two {m n : ℕ} (hm1 : m % 2 = 1) (hn1 : n % 2 = 1) :

m * n / 2 = m * (n / 2) + m / 2

theorem Nat.odd_of_mod_four_eq_one {n : ℕ} :

n % 4 = 1 → n % 2 = 1

theorem Nat.odd_of_mod_four_eq_three {n : ℕ} :

n % 4 = 3 → n % 2 = 1

theorem Nat.odd_mod_four_iff {n : ℕ} :

n % 2 = 1 ↔ n % 4 = 1 ∨ n % 4 = 3

A natural number is odd iff it has residue 1 or 3 mod 4.

theorem Nat.mod_eq_of_modEq {a b n : ℕ} (h : a ≡ b [MOD n]) (hb : b < n) :

a % n = b

theorem Nat.ext_div_modEq {n a b : ℕ} (h0 : a / n = b / n) (h1 : a ≡ b [MOD n]) :

a = b

theorem Nat.ext_div_modEq_iff (n a b : ℕ) :

a = b ↔ a / n = b / n ∧ a ≡ b [MOD n]