HepLean Documentation

Mathlib.NumberTheory.Divisors

Divisor Finsets #

This file defines sets of divisors of a natural number. This is particularly useful as background for defining Dirichlet convolution.

Main Definitions #

Let n : ℕ. All of the following definitions are in the Nat namespace:

divisors n is the Finset of natural numbers that divide n.
properDivisors n is the Finset of natural numbers that divide n, other than n.
divisorsAntidiagonal n is the Finset of pairs (x,y) such that x * y = n.
Perfect n is true when n is positive and the sum of properDivisors n is n.

Implementation details #

divisors 0, properDivisors 0, and divisorsAntidiagonal 0 are defined to be ∅.

Tags #

divisors, perfect numbers

def Nat.divisors (n : ℕ) :

divisors n is the Finset of divisors of n. As a special case, divisors 0 = ∅.

Equations

n.divisors = Finset.filter (fun (d : ℕ) => d ∣ n) (Finset.Ico 1 (n + 1))

Instances For

def Nat.properDivisors (n : ℕ) :

properDivisors n is the Finset of divisors of n, other than n. As a special case, properDivisors 0 = ∅.

Equations

n.properDivisors = Finset.filter (fun (d : ℕ) => d ∣ n) (Finset.Ico 1 n)

Instances For

def Nat.divisorsAntidiagonal (n : ℕ) :

Finset (ℕ × ℕ)

divisorsAntidiagonal n is the Finset of pairs (x,y) such that x * y = n. As a special case, divisorsAntidiagonal 0 = ∅.

Equations

n.divisorsAntidiagonal = Finset.filter (fun (x : ℕ × ℕ) => x.1 * x.2 = n) (Finset.Ico 1 (n + 1) ×ˢ Finset.Ico 1 (n + 1))

Instances For

@[simp]

theorem Nat.filter_dvd_eq_divisors {n : ℕ} (h : n ≠ 0) :

Finset.filter (fun (d : ℕ) => d ∣ n) (Finset.range n.succ) = n.divisors

@[simp]

theorem Nat.filter_dvd_eq_properDivisors {n : ℕ} (h : n ≠ 0) :

Finset.filter (fun (d : ℕ) => d ∣ n) (Finset.range n) = n.properDivisors

theorem Nat.properDivisors.not_self_mem {n : ℕ} :

n ∉ n.properDivisors

@[simp]

theorem Nat.mem_properDivisors {n : ℕ} {m : ℕ} :

n ∈ m.properDivisors ↔ n ∣ m ∧ n < m

theorem Nat.insert_self_properDivisors {n : ℕ} (h : n ≠ 0) :

insert n n.properDivisors = n.divisors

theorem Nat.cons_self_properDivisors {n : ℕ} (h : n ≠ 0) :

Finset.cons n n.properDivisors ⋯ = n.divisors

@[simp]

theorem Nat.mem_divisors {n : ℕ} {m : ℕ} :

n ∈ m.divisors ↔ n ∣ m ∧ m ≠ 0

theorem Nat.one_mem_divisors {n : ℕ} :

1 ∈ n.divisors ↔ n ≠ 0

theorem Nat.mem_divisors_self (n : ℕ) (h : n ≠ 0) :

n ∈ n.divisors

theorem Nat.dvd_of_mem_divisors {n : ℕ} {m : ℕ} (h : n ∈ m.divisors) :

n ∣ m

@[simp]

theorem Nat.mem_divisorsAntidiagonal {n : ℕ} {x : ℕ × ℕ} :

x ∈ n.divisorsAntidiagonal ↔ x.1 * x.2 = n ∧ n ≠ 0

theorem Nat.ne_zero_of_mem_divisorsAntidiagonal {n : ℕ} {p : ℕ × ℕ} (hp : p ∈ n.divisorsAntidiagonal) :

p.1 ≠ 0 ∧ p.2 ≠ 0

theorem Nat.left_ne_zero_of_mem_divisorsAntidiagonal {n : ℕ} {p : ℕ × ℕ} (hp : p ∈ n.divisorsAntidiagonal) :

p.1 ≠ 0

theorem Nat.right_ne_zero_of_mem_divisorsAntidiagonal {n : ℕ} {p : ℕ × ℕ} (hp : p ∈ n.divisorsAntidiagonal) :

p.2 ≠ 0

theorem Nat.divisor_le {n : ℕ} {m : ℕ} :

n ∈ m.divisors → n ≤ m

theorem Nat.divisors_subset_of_dvd {n : ℕ} {m : ℕ} (hzero : n ≠ 0) (h : m ∣ n) :

m.divisors ⊆ n.divisors

theorem Nat.divisors_subset_properDivisors {n : ℕ} {m : ℕ} (hzero : n ≠ 0) (h : m ∣ n) (hdiff : m ≠ n) :

m.divisors ⊆ n.properDivisors

theorem Nat.divisors_filter_dvd_of_dvd {n : ℕ} {m : ℕ} (hn : n ≠ 0) (hm : m ∣ n) :

Finset.filter (fun (d : ℕ) => d ∣ m) n.divisors = m.divisors

@[simp]

theorem Nat.divisors_zero :

Nat.divisors 0 = ∅

@[simp]

theorem Nat.properDivisors_zero :

Nat.properDivisors 0 = ∅

@[simp]

theorem Nat.nonempty_divisors {n : ℕ} :

n.divisors.Nonempty ↔ n ≠ 0

@[simp]

theorem Nat.divisors_eq_empty {n : ℕ} :

n.divisors = ∅ ↔ n = 0

theorem Nat.properDivisors_subset_divisors {n : ℕ} :

n.properDivisors ⊆ n.divisors

@[simp]

theorem Nat.divisors_one :

Nat.divisors 1 = {1}

@[simp]

theorem Nat.properDivisors_one :

Nat.properDivisors 1 = ∅

theorem Nat.pos_of_mem_divisors {n : ℕ} {m : ℕ} (h : m ∈ n.divisors) :

0 < m

theorem Nat.pos_of_mem_properDivisors {n : ℕ} {m : ℕ} (h : m ∈ n.properDivisors) :

0 < m

theorem Nat.one_mem_properDivisors_iff_one_lt {n : ℕ} :

1 ∈ n.properDivisors ↔ 1 < n

@[simp]

theorem Nat.sup_divisors_id (n : ℕ) :

n.divisors.sup id = n

theorem Nat.one_lt_of_mem_properDivisors {m : ℕ} {n : ℕ} (h : m ∈ n.properDivisors) :

1 < n

theorem Nat.one_lt_div_of_mem_properDivisors {m : ℕ} {n : ℕ} (h : m ∈ n.properDivisors) :

1 < n / m

theorem Nat.mem_properDivisors_iff_exists {m : ℕ} {n : ℕ} (hn : n ≠ 0) :

m ∈ n.properDivisors ↔ ∃ k > 1, n = m * k

See also Nat.mem_properDivisors.

@[simp]

theorem Nat.nonempty_properDivisors {n : ℕ} :

n.properDivisors.Nonempty ↔ 1 < n

@[simp]

theorem Nat.properDivisors_eq_empty {n : ℕ} :

n.properDivisors = ∅ ↔ n ≤ 1

@[simp]

theorem Nat.divisorsAntidiagonal_zero :

Nat.divisorsAntidiagonal 0 = ∅

@[simp]

theorem Nat.divisorsAntidiagonal_one :

Nat.divisorsAntidiagonal 1 = {(1, 1)}

theorem Nat.swap_mem_divisorsAntidiagonal {n : ℕ} {x : ℕ × ℕ} :

x.swap ∈ n.divisorsAntidiagonal ↔ x ∈ n.divisorsAntidiagonal

@[simp]

theorem Nat.swap_mem_divisorsAntidiagonal_aux {n : ℕ} {x : ℕ × ℕ} :

x.2 * x.1 = n ∧ ¬n = 0 ↔ x ∈ n.divisorsAntidiagonal

theorem Nat.fst_mem_divisors_of_mem_antidiagonal {n : ℕ} {x : ℕ × ℕ} (h : x ∈ n.divisorsAntidiagonal) :

x.1 ∈ n.divisors

theorem Nat.snd_mem_divisors_of_mem_antidiagonal {n : ℕ} {x : ℕ × ℕ} (h : x ∈ n.divisorsAntidiagonal) :

x.2 ∈ n.divisors

@[simp]

theorem Nat.map_swap_divisorsAntidiagonal {n : ℕ} :

Finset.map (Equiv.prodComm ℕ ℕ).toEmbedding n.divisorsAntidiagonal = n.divisorsAntidiagonal

@[simp]

theorem Nat.image_fst_divisorsAntidiagonal {n : ℕ} :

Finset.image Prod.fst n.divisorsAntidiagonal = n.divisors

@[simp]

theorem Nat.image_snd_divisorsAntidiagonal {n : ℕ} :

Finset.image Prod.snd n.divisorsAntidiagonal = n.divisors

theorem Nat.map_div_right_divisors {n : ℕ} :

Finset.map { toFun := fun (d : ℕ) => (d, n / d), inj' := ⋯ } n.divisors = n.divisorsAntidiagonal

theorem Nat.map_div_left_divisors {n : ℕ} :

Finset.map { toFun := fun (d : ℕ) => (n / d, d), inj' := ⋯ } n.divisors = n.divisorsAntidiagonal

theorem Nat.sum_divisors_eq_sum_properDivisors_add_self {n : ℕ} :

∑ i ∈ n.divisors, i = ∑ i ∈ n.properDivisors, i + n

def Nat.Perfect (n : ℕ) :

n : ℕ is perfect if and only the sum of the proper divisors of n is n and n is positive.

Equations

n.Perfect = (∑ i ∈ n.properDivisors, i = n ∧ 0 < n)

Instances For

theorem Nat.perfect_iff_sum_properDivisors {n : ℕ} (h : 0 < n) :

n.Perfect ↔ ∑ i ∈ n.properDivisors, i = n

theorem Nat.perfect_iff_sum_divisors_eq_two_mul {n : ℕ} (h : 0 < n) :

n.Perfect ↔ ∑ i ∈ n.divisors, i = 2 * n

theorem Nat.mem_divisors_prime_pow {p : ℕ} (pp : Nat.Prime p) (k : ℕ) {x : ℕ} :

x ∈ (p ^ k).divisors ↔ ∃ j ≤ k, x = p ^ j

theorem Nat.Prime.divisors {p : ℕ} (pp : Nat.Prime p) :

p.divisors = {1, p}

theorem Nat.Prime.properDivisors {p : ℕ} (pp : Nat.Prime p) :

p.properDivisors = {1}

theorem Nat.divisors_prime_pow {p : ℕ} (pp : Nat.Prime p) (k : ℕ) :

(p ^ k).divisors = Finset.map { toFun := fun (x : ℕ) => p ^ x, inj' := ⋯ } (Finset.range (k + 1))

theorem Nat.divisors_injective :

Function.Injective Nat.divisors

@[simp]

theorem Nat.divisors_inj {a : ℕ} {b : ℕ} :

a.divisors = b.divisors ↔ a = b

theorem Nat.eq_properDivisors_of_subset_of_sum_eq_sum {n : ℕ} {s : Finset ℕ} (hsub : s ⊆ n.properDivisors) :

∑ x ∈ s, x = ∑ x ∈ n.properDivisors, x → s = n.properDivisors

theorem Nat.sum_properDivisors_dvd {n : ℕ} (h : ∑ x ∈ n.properDivisors, x ∣ n) :

∑ x ∈ n.properDivisors, x = 1 ∨ ∑ x ∈ n.properDivisors, x = n

@[simp]

theorem Nat.Prime.sum_properDivisors {α : Type u_1} [AddCommMonoid α] {p : ℕ} {f : ℕ → α} (h : Nat.Prime p) :

∑ x ∈ p.properDivisors, f x = f 1

@[simp]

theorem Nat.Prime.prod_properDivisors {α : Type u_1} [CommMonoid α] {p : ℕ} {f : ℕ → α} (h : Nat.Prime p) :

∏ x ∈ p.properDivisors, f x = f 1

@[simp]

theorem Nat.Prime.sum_divisors {α : Type u_1} [AddCommMonoid α] {p : ℕ} {f : ℕ → α} (h : Nat.Prime p) :

∑ x ∈ p.divisors, f x = f p + f 1

@[simp]

theorem Nat.Prime.prod_divisors {α : Type u_1} [CommMonoid α] {p : ℕ} {f : ℕ → α} (h : Nat.Prime p) :

∏ x ∈ p.divisors, f x = f p * f 1

theorem Nat.properDivisors_eq_singleton_one_iff_prime {n : ℕ} :

n.properDivisors = {1} ↔ Nat.Prime n

theorem Nat.sum_properDivisors_eq_one_iff_prime {n : ℕ} :

∑ x ∈ n.properDivisors, x = 1 ↔ Nat.Prime n

theorem Nat.mem_properDivisors_prime_pow {p : ℕ} (pp : Nat.Prime p) (k : ℕ) {x : ℕ} :

x ∈ (p ^ k).properDivisors ↔ ∃ (j : ℕ) (_ : j < k), x = p ^ j

theorem Nat.properDivisors_prime_pow {p : ℕ} (pp : Nat.Prime p) (k : ℕ) :

(p ^ k).properDivisors = Finset.map { toFun := fun (x : ℕ) => p ^ x, inj' := ⋯ } (Finset.range k)

@[simp]

theorem Nat.sum_properDivisors_prime_nsmul {α : Type u_1} [AddCommMonoid α] {k : ℕ} {p : ℕ} {f : ℕ → α} (h : Nat.Prime p) :

∑ x ∈ (p ^ k).properDivisors, f x = ∑ x ∈ Finset.range k, f (p ^ x)

@[simp]

theorem Nat.prod_properDivisors_prime_pow {α : Type u_1} [CommMonoid α] {k : ℕ} {p : ℕ} {f : ℕ → α} (h : Nat.Prime p) :

∏ x ∈ (p ^ k).properDivisors, f x = ∏ x ∈ Finset.range k, f (p ^ x)

@[simp]

theorem Nat.sum_divisors_prime_pow {α : Type u_1} [AddCommMonoid α] {k : ℕ} {p : ℕ} {f : ℕ → α} (h : Nat.Prime p) :

∑ x ∈ (p ^ k).divisors, f x = ∑ x ∈ Finset.range (k + 1), f (p ^ x)

@[simp]

theorem Nat.prod_divisors_prime_pow {α : Type u_1} [CommMonoid α] {k : ℕ} {p : ℕ} {f : ℕ → α} (h : Nat.Prime p) :

∏ x ∈ (p ^ k).divisors, f x = ∏ x ∈ Finset.range (k + 1), f (p ^ x)

theorem Nat.sum_divisorsAntidiagonal {M : Type u_1} [AddCommMonoid M] (f : ℕ → ℕ → M) {n : ℕ} :

∑ i ∈ n.divisorsAntidiagonal, f i.1 i.2 = ∑ i ∈ n.divisors, f i (n / i)

theorem Nat.prod_divisorsAntidiagonal {M : Type u_1} [CommMonoid M] (f : ℕ → ℕ → M) {n : ℕ} :

∏ i ∈ n.divisorsAntidiagonal, f i.1 i.2 = ∏ i ∈ n.divisors, f i (n / i)

theorem Nat.sum_divisorsAntidiagonal' {M : Type u_1} [AddCommMonoid M] (f : ℕ → ℕ → M) {n : ℕ} :

∑ i ∈ n.divisorsAntidiagonal, f i.1 i.2 = ∑ i ∈ n.divisors, f (n / i) i

theorem Nat.prod_divisorsAntidiagonal' {M : Type u_1} [CommMonoid M] (f : ℕ → ℕ → M) {n : ℕ} :

∏ i ∈ n.divisorsAntidiagonal, f i.1 i.2 = ∏ i ∈ n.divisors, f (n / i) i

theorem Nat.primeFactors_eq_to_filter_divisors_prime (n : ℕ) :

n.primeFactors = Finset.filter (fun (p : ℕ) => Nat.Prime p) n.divisors

The factors of n are the prime divisors

@[deprecated Nat.primeFactors_eq_to_filter_divisors_prime]

theorem Nat.prime_divisors_eq_to_filter_divisors_prime (n : ℕ) :

n.primeFactors = Finset.filter (fun (p : ℕ) => Nat.Prime p) n.divisors

Alias of Nat.primeFactors_eq_to_filter_divisors_prime.

The factors of n are the prime divisors

theorem Nat.primeFactors_filter_dvd_of_dvd {m : ℕ} {n : ℕ} (hn : n ≠ 0) (hmn : m ∣ n) :

Finset.filter (fun (p : ℕ) => p ∣ m) n.primeFactors = m.primeFactors

@[deprecated Nat.primeFactors_filter_dvd_of_dvd]

theorem Nat.prime_divisors_filter_dvd_of_dvd {m : ℕ} {n : ℕ} (hn : n ≠ 0) (hmn : m ∣ n) :

Finset.filter (fun (p : ℕ) => p ∣ m) n.primeFactors = m.primeFactors

Alias of Nat.primeFactors_filter_dvd_of_dvd.

@[simp]

theorem Nat.image_div_divisors_eq_divisors (n : ℕ) :

Finset.image (fun (x : ℕ) => n / x) n.divisors = n.divisors

theorem Nat.sum_div_divisors {α : Type u_1} [AddCommMonoid α] (n : ℕ) (f : ℕ → α) :

∑ d ∈ n.divisors, f (n / d) = n.divisors.sum f

theorem Nat.prod_div_divisors {α : Type u_1} [CommMonoid α] (n : ℕ) (f : ℕ → α) :

∏ d ∈ n.divisors, f (n / d) = n.divisors.prod f