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 : ℕ) : Finset ℕ

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

Equations

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

def Nat.properDivisors (n : ℕ) : Finset ℕ

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

Equations

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

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))

@[simp]

theorem Nat.filter_dvd_eq_divisors {n : ℕ} (h : n ≠ 0) : Finset.filter (fun (x : ℕ) => x ∣ n) (Finset.range n.succ) = n.divisors

@[simp]

theorem Nat.filter_dvd_eq_properDivisors {n : ℕ} (h : n ≠ 0) : Finset.filter (fun (x : ℕ) => x ∣ 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 (x : ℕ) => x ∣ 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 : ℕ} : (n.divisors.sum fun (i : ℕ) => i) = (n.properDivisors.sum fun (i : ℕ) => i) + n

def Nat.Perfect (n : ℕ) : Prop

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

Equations

• n.Perfect = ((n.properDivisors.sum fun (i : ℕ) => i) = n ∧ 0 < n)

theorem Nat.perfect_iff_sum_properDivisors {n : ℕ} (h : 0 < n) : n.Perfect ↔ (n.properDivisors.sum fun (i : ℕ) => i) = n

theorem Nat.perfect_iff_sum_divisors_eq_two_mul {n : ℕ} (h : 0 < n) : n.Perfect ↔ (n.divisors.sum fun (i : ℕ) => i) = 2 * n

theorem Nat.mem_divisors_prime_pow {p : ℕ} (pp : p.Prime) (k : ℕ) {x : ℕ} : x ∈ (p ^ k).divisors ↔ ∃ j ≤ k, x = p ^ j

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

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

theorem Nat.divisors_prime_pow {p : ℕ} (pp : p.Prime) (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) : ((s.sum fun (x : ℕ) => x) = n.properDivisors.sum fun (x : ℕ) => x) → s = n.properDivisors

theorem Nat.sum_properDivisors_dvd {n : ℕ} (h : (n.properDivisors.sum fun (x : ℕ) => x) ∣ n) : (n.properDivisors.sum fun (x : ℕ) => x) = 1 ∨ (n.properDivisors.sum fun (x : ℕ) => x) = n

@[simp]

theorem Nat.Prime.sum_properDivisors {α : Type u_1} [AddCommMonoid α] {p : ℕ} {f : ℕ → α} (h : p.Prime) : (p.properDivisors.sum fun (x : ℕ) => f x) = f 1

@[simp]

theorem Nat.Prime.prod_properDivisors {α : Type u_1} [CommMonoid α] {p : ℕ} {f : ℕ → α} (h : p.Prime) : (p.properDivisors.prod fun (x : ℕ) => f x) = f 1

@[simp]

theorem Nat.Prime.sum_divisors {α : Type u_1} [AddCommMonoid α] {p : ℕ} {f : ℕ → α} (h : p.Prime) : (p.divisors.sum fun (x : ℕ) => f x) = f p + f 1

@[simp]

theorem Nat.Prime.prod_divisors {α : Type u_1} [CommMonoid α] {p : ℕ} {f : ℕ → α} (h : p.Prime) : (p.divisors.prod fun (x : ℕ) => f x) = f p * f 1

theorem Nat.properDivisors_eq_singleton_one_iff_prime {n : ℕ} : n.properDivisors = {1} ↔ n.Prime

theorem Nat.sum_properDivisors_eq_one_iff_prime {n : ℕ} : (n.properDivisors.sum fun (x : ℕ) => x) = 1 ↔ n.Prime

theorem Nat.mem_properDivisors_prime_pow {p : ℕ} (pp : p.Prime) (k : ℕ) {x : ℕ} : x ∈ (p ^ k).properDivisors ↔ ∃ (j : ℕ) (_ : j < k), x = p ^ j

theorem Nat.properDivisors_prime_pow {p : ℕ} (pp : p.Prime) (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 : p.Prime) : ((p ^ k).properDivisors.sum fun (x : ℕ) => f x) = (Finset.range k).sum fun (x : ℕ) => f (p ^ x)

@[simp]

theorem Nat.prod_properDivisors_prime_pow {α : Type u_1} [CommMonoid α] {k : ℕ} {p : ℕ} {f : ℕ → α} (h : p.Prime) : ((p ^ k).properDivisors.prod fun (x : ℕ) => f x) = (Finset.range k).prod fun (x : ℕ) => f (p ^ x)

@[simp]

theorem Nat.sum_divisors_prime_pow {α : Type u_1} [AddCommMonoid α] {k : ℕ} {p : ℕ} {f : ℕ → α} (h : p.Prime) : ((p ^ k).divisors.sum fun (x : ℕ) => f x) = (Finset.range (k + 1)).sum fun (x : ℕ) => f (p ^ x)

@[simp]

theorem Nat.prod_divisors_prime_pow {α : Type u_1} [CommMonoid α] {k : ℕ} {p : ℕ} {f : ℕ → α} (h : p.Prime) : ((p ^ k).divisors.prod fun (x : ℕ) => f x) = (Finset.range (k + 1)).prod fun (x : ℕ) => f (p ^ x)

theorem Nat.sum_divisorsAntidiagonal {M : Type u_1} [AddCommMonoid M] (f : ℕ → ℕ → M) {n : ℕ} : (n.divisorsAntidiagonal.sum fun (i : ℕ × ℕ) => f i.1 i.2) = n.divisors.sum fun (i : ℕ) => f i (n / i)

theorem Nat.prod_divisorsAntidiagonal {M : Type u_1} [CommMonoid M] (f : ℕ → ℕ → M) {n : ℕ} : (n.divisorsAntidiagonal.prod fun (i : ℕ × ℕ) => f i.1 i.2) = n.divisors.prod fun (i : ℕ) => f i (n / i)

theorem Nat.sum_divisorsAntidiagonal' {M : Type u_1} [AddCommMonoid M] (f : ℕ → ℕ → M) {n : ℕ} : (n.divisorsAntidiagonal.sum fun (i : ℕ × ℕ) => f i.1 i.2) = n.divisors.sum fun (i : ℕ) => f (n / i) i

theorem Nat.prod_divisorsAntidiagonal' {M : Type u_1} [CommMonoid M] (f : ℕ → ℕ → M) {n : ℕ} : (n.divisorsAntidiagonal.prod fun (i : ℕ × ℕ) => f i.1 i.2) = n.divisors.prod fun (i : ℕ) => f (n / i) i

theorem Nat.prime_divisors_eq_to_filter_divisors_prime (n : ℕ) : n.factors.toFinset = Finset.filter Nat.Prime n.divisors

The factors of n are the prime divisors

theorem Nat.prime_divisors_filter_dvd_of_dvd {m : ℕ} {n : ℕ} (hn : n ≠ 0) (hmn : m ∣ n) : Finset.filter (fun (x : ℕ) => x ∣ m) n.factors.toFinset = m.factors.toFinset

@[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 : ℕ → α) : (n.divisors.sum fun (d : ℕ) => f (n / d)) = n.divisors.sum f

theorem Nat.prod_div_divisors {α : Type u_1} [CommMonoid α] (n : ℕ) (f : ℕ → α) : (n.divisors.prod fun (d : ℕ) => f (n / d)) = n.divisors.prod f