Split (1)

train · 193k rows

fact stringlengths 6 3.84k	type stringclasses 11 values	library stringclasses 32 values	imports listlengths 1 14	filename stringlengths 20 95	symbolic_name stringlengths 1 90	docstring stringlengths 7 20k ⌀
map_div_right_divisors : n.divisors.map ⟨fun d => (d, n / d), fun _ _ => congr_arg Prod.fst⟩ = n.divisorsAntidiagonal := by ext ⟨d, nd⟩ simp only [mem_map, mem_divisorsAntidiagonal, Function.Embedding.coeFn_mk, mem_divisors, Prod.ext_iff, and_left_comm, exists_eq_left] constructor · rintro ⟨⟨⟨k, r...	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	map_div_right_divisors	null
map_div_left_divisors : n.divisors.map ⟨fun d => (n / d, d), fun _ _ => congr_arg Prod.snd⟩ = n.divisorsAntidiagonal := by apply Finset.map_injective (Equiv.prodComm _ _).toEmbedding ext rw [map_swap_divisorsAntidiagonal, ← map_div_right_divisors, Finset.map_map] simp	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	map_div_left_divisors	null
sum_divisors_eq_sum_properDivisors_add_self : ∑ i ∈ divisors n, i = (∑ i ∈ properDivisors n, i) + n := by rcases Decidable.eq_or_ne n 0 with (rfl \| hn) · simp · rw [← cons_self_properDivisors hn, Finset.sum_cons, add_comm]	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	sum_divisors_eq_sum_properDivisors_add_self	null
Perfect (n : ℕ) : Prop := ∑ i ∈ properDivisors n, i = n ∧ 0 < n	def	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	Perfect	`n : ℕ` is perfect if and only the sum of the proper divisors of `n` is `n` and `n` is positive.
perfect_iff_sum_properDivisors (h : 0 < n) : Perfect n ↔ ∑ i ∈ properDivisors n, i = n := and_iff_left h	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	perfect_iff_sum_properDivisors	null
perfect_iff_sum_divisors_eq_two_mul (h : 0 < n) : Perfect n ↔ ∑ i ∈ divisors n, i = 2 * n := by rw [perfect_iff_sum_properDivisors h, sum_divisors_eq_sum_properDivisors_add_self, two_mul] constructor <;> intro h · rw [h] · apply add_right_cancel h	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	perfect_iff_sum_divisors_eq_two_mul	null
mem_divisors_prime_pow {p : ℕ} (pp : p.Prime) (k : ℕ) {x : ℕ} : x ∈ divisors (p ^ k) ↔ ∃ j ≤ k, x = p ^ j := by rw [mem_divisors, Nat.dvd_prime_pow pp, and_iff_left (ne_of_gt (pow_pos pp.pos k))]	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	mem_divisors_prime_pow	null
Prime.divisors {p : ℕ} (pp : p.Prime) : divisors p = {1, p} := by ext rw [mem_divisors, dvd_prime pp, and_iff_left pp.ne_zero, Finset.mem_insert, Finset.mem_singleton]	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	Prime.divisors	null
Prime.properDivisors {p : ℕ} (pp : p.Prime) : properDivisors p = {1} := by rw [← erase_insert self_notMem_properDivisors, insert_self_properDivisors pp.ne_zero, pp.divisors, pair_comm, erase_insert fun con => pp.ne_one (mem_singleton.1 con)]	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	Prime.properDivisors	null
divisors_prime_pow {p : ℕ} (pp : p.Prime) (k : ℕ) : divisors (p ^ k) = (Finset.range (k + 1)).map ⟨(p ^ ·), Nat.pow_right_injective pp.two_le⟩ := by ext a rw [mem_divisors_prime_pow pp] simp [Nat.lt_succ, eq_comm]	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	divisors_prime_pow	null
divisors_injective : Function.Injective divisors := Function.LeftInverse.injective sup_divisors_id @[simp]	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	divisors_injective	null
divisors_inj {a b : ℕ} : a.divisors = b.divisors ↔ a = b := divisors_injective.eq_iff	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	divisors_inj	null
eq_properDivisors_of_subset_of_sum_eq_sum {s : Finset ℕ} (hsub : s ⊆ n.properDivisors) : ((∑ x ∈ s, x) = ∑ x ∈ n.properDivisors, x) → s = n.properDivisors := by cases n · rw [properDivisors_zero, subset_empty] at hsub simp [hsub] classical rw [← sum_sdiff hsub] intro h apply Subset.antisymm hs...	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	eq_properDivisors_of_subset_of_sum_eq_sum	null
sum_properDivisors_dvd (h : (∑ x ∈ n.properDivisors, x) ∣ n) : ∑ x ∈ n.properDivisors, x = 1 ∨ ∑ x ∈ n.properDivisors, x = n := by rcases n with - \| n · simp · rcases n with - \| n · simp at h · rw [or_iff_not_imp_right] intro ne_n have hlt : ∑ x ∈ n.succ.succ.properDivisors, x < n.succ.suc...	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	sum_properDivisors_dvd	null
Prime.prod_properDivisors {α : Type*} [CommMonoid α] {p : ℕ} {f : ℕ → α} (h : p.Prime) : ∏ x ∈ p.properDivisors, f x = f 1 := by simp [h.properDivisors] @[to_additive (attr := simp)]	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	Prime.prod_properDivisors	null
Prime.prod_divisors {α : Type} [CommMonoid α] {p : ℕ} {f : ℕ → α} (h : p.Prime) : ∏ x ∈ p.divisors, f x = f p f 1 := by rw [← cons_self_properDivisors h.ne_zero, prod_cons, h.prod_properDivisors]	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	Prime.prod_divisors	null
properDivisors_eq_singleton_one_iff_prime : n.properDivisors = {1} ↔ n.Prime := by refine ⟨?_, ?_⟩ · intro h refine Nat.prime_def.mpr ⟨?_, fun m hdvd => ?_⟩ · match n with \| 0 => contradiction \| 1 => contradiction \| Nat.succ (Nat.succ n) => simp · rw [← mem_singleton, ← h, mem_properDi...	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	properDivisors_eq_singleton_one_iff_prime	null
sum_properDivisors_eq_one_iff_prime : ∑ x ∈ n.properDivisors, x = 1 ↔ n.Prime := by rcases n with - \| n · simp [Nat.not_prime_zero] · cases n · simp [Nat.not_prime_one] · rw [← properDivisors_eq_singleton_one_iff_prime] refine ⟨fun h => ?_, fun h => h.symm ▸ sum_singleton _ _⟩ rw [@eq_comm (Fi...	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	sum_properDivisors_eq_one_iff_prime	null
mem_properDivisors_prime_pow {p : ℕ} (pp : p.Prime) (k : ℕ) {x : ℕ} : x ∈ properDivisors (p ^ k) ↔ ∃ (j : ℕ) (_ : j < k), x = p ^ j := by rw [mem_properDivisors, Nat.dvd_prime_pow pp, ← exists_and_right] simp only [exists_prop, and_assoc] apply exists_congr intro a constructor <;> intro h · rcases h wit...	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	mem_properDivisors_prime_pow	null
properDivisors_prime_pow {p : ℕ} (pp : p.Prime) (k : ℕ) : properDivisors (p ^ k) = (Finset.range k).map ⟨(p ^ ·), Nat.pow_right_injective pp.two_le⟩ := by ext a simp only [mem_properDivisors, mem_map, mem_range, Function.Embedding.coeFn_mk] have := mem_properDivisors_prime_pow pp k (x := a) rw [mem_properDi...	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	properDivisors_prime_pow	null
prod_properDivisors_prime_pow {α : Type*} [CommMonoid α] {k p : ℕ} {f : ℕ → α} (h : p.Prime) : (∏ x ∈ (p ^ k).properDivisors, f x) = ∏ x ∈ range k, f (p ^ x) := by simp [h, properDivisors_prime_pow] @[to_additive (attr := simp) sum_divisors_prime_pow]	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	prod_properDivisors_prime_pow	null
prod_divisors_prime_pow {α : Type*} [CommMonoid α] {k p : ℕ} {f : ℕ → α} (h : p.Prime) : (∏ x ∈ (p ^ k).divisors, f x) = ∏ x ∈ range (k + 1), f (p ^ x) := by simp [h, divisors_prime_pow] @[to_additive]	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	prod_divisors_prime_pow	null
prod_divisorsAntidiagonal {M : Type*} [CommMonoid M] (f : ℕ → ℕ → M) {n : ℕ} : ∏ i ∈ n.divisorsAntidiagonal, f i.1 i.2 = ∏ i ∈ n.divisors, f i (n / i) := by rw [← map_div_right_divisors, Finset.prod_map] rfl @[to_additive]	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	prod_divisorsAntidiagonal	null
prod_divisorsAntidiagonal' {M : Type*} [CommMonoid M] (f : ℕ → ℕ → M) {n : ℕ} : ∏ i ∈ n.divisorsAntidiagonal, f i.1 i.2 = ∏ i ∈ n.divisors, f (n / i) i := by rw [← map_swap_divisorsAntidiagonal, Finset.prod_map] exact prod_divisorsAntidiagonal fun i j => f j i	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	prod_divisorsAntidiagonal'	null
primeFactors_eq_to_filter_divisors_prime (n : ℕ) : n.primeFactors = {p ∈ divisors n \| p.Prime} := by rcases n.eq_zero_or_pos with (rfl \| hn) · simp · ext q simpa [hn, hn.ne', mem_primeFactorsList] using and_comm	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	primeFactors_eq_to_filter_divisors_prime	The factors of `n` are the prime divisors
primeFactors_filter_dvd_of_dvd {m n : ℕ} (hn : n ≠ 0) (hmn : m ∣ n) : {p ∈ n.primeFactors \| p ∣ m} = m.primeFactors := by simp_rw [primeFactors_eq_to_filter_divisors_prime, filter_comm, divisors_filter_dvd_of_dvd hn hmn] @[simp]	lemma	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	primeFactors_filter_dvd_of_dvd	null
image_div_divisors_eq_divisors (n : ℕ) : image (fun x : ℕ => n / x) n.divisors = n.divisors := by by_cases hn : n = 0 · simp [hn] ext a constructor · rw [mem_image] rintro ⟨x, hx1, hx2⟩ rw [mem_divisors] at * refine ⟨?_, hn⟩ rw [← hx2] exact div_dvd_of_dvd hx1.1 · rw [mem_divisors, m...	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	image_div_divisors_eq_divisors	null
prod_div_divisors {α : Type*} [CommMonoid α] (n : ℕ) (f : ℕ → α) : (∏ d ∈ n.divisors, f (n / d)) = n.divisors.prod f := by by_cases hn : n = 0; · simp [hn] rw [← prod_image] · exact prod_congr (image_div_divisors_eq_divisors n) (by simp) · intro x hx y hy h rw [mem_coe, mem_divisors] at hx hy exact ...	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	prod_div_divisors	null
disjoint_divisors_filter_isPrimePow {a b : ℕ} (hab : a.Coprime b) : Disjoint (a.divisors.filter IsPrimePow) (b.divisors.filter IsPrimePow) := by simp only [Finset.disjoint_left, Finset.mem_filter, and_imp, Nat.mem_divisors, not_and] rintro n han _ha hn hbn _hb - exact hn.ne_one (Nat.eq_one_of_dvd_coprimes hab...	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	disjoint_divisors_filter_isPrimePow	null
divisorsAntidiag : (z : ℤ) → Finset (ℤ × ℤ) \| (n : ℕ) => let s : Finset (ℕ × ℕ) := n.divisorsAntidiagonal (s.map <\| .prodMap natCast natCast).disjUnion (s.map <\| .prodMap negNatCast negNatCast) <\| by simp +contextual [s, disjoint_left, eq_comm] \| negSucc n => let s : Finset (ℕ × ℕ) := (n + 1).divi...	def	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	divisorsAntidiag	Pairs of divisors of an integer as a finset. `z.divisorsAntidiag` is the finset of pairs `(a, b) : ℤ × ℤ` such that `a * b = z`. By convention, we set `Int.divisorsAntidiag 0 = ∅`. O(\|z\|). Computed from `Nat.divisorsAntidiagonal`.
mem_divisorsAntidiag : ∀ {z} {xy : ℤ × ℤ}, xy ∈ divisorsAntidiag z ↔ xy.fst * xy.snd = z ∧ z ≠ 0 \| (n : ℕ), ((x : ℕ), (y : ℕ)) => by simp [divisorsAntidiag] norm_cast simp +contextual [eq_comm] \| (n : ℕ), (negSucc x, negSucc y) => by simp [divisorsAntidiag, negSucc_eq, -neg_add_rev] norm_cas...	lemma	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	mem_divisorsAntidiag	null
divisorsAntidiagonal_one : Int.divisorsAntidiag 1 = {(1, 1), (-1, -1)} := rfl @[simp]	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	divisorsAntidiagonal_one	null
divisorsAntidiagonal_two : Int.divisorsAntidiag 2 = {(1, 2), (2, 1), (-1, -2), (-2, -1)} := rfl @[simp]	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	divisorsAntidiagonal_two	null
divisorsAntidiagonal_three : Int.divisorsAntidiag 3 = {(1, 3), (3, 1), (-1, -3), (-3, -1)} := rfl @[simp]	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	divisorsAntidiagonal_three	null
divisorsAntidiagonal_four : Int.divisorsAntidiag 4 = {(1, 4), (2, 2), (4, 1), (-1, -4), (-2, -2), (-4, -1)} := rfl	theorem	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	divisorsAntidiagonal_four	null
prodMk_mem_divisorsAntidiag (hz : z ≠ 0) : (x, y) ∈ z.divisorsAntidiag ↔ x * y = z := by simp [hz] @[simp high]	lemma	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	prodMk_mem_divisorsAntidiag	null
swap_mem_divisorsAntidiag : xy.swap ∈ z.divisorsAntidiag ↔ xy ∈ z.divisorsAntidiag := by simp [mul_comm]	lemma	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	swap_mem_divisorsAntidiag	null
neg_mem_divisorsAntidiag : -xy ∈ z.divisorsAntidiag ↔ xy ∈ z.divisorsAntidiag := by simp @[simp]	lemma	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	neg_mem_divisorsAntidiag	null
map_prodComm_divisorsAntidiag : z.divisorsAntidiag.map (Equiv.prodComm _ _).toEmbedding = z.divisorsAntidiag := by ext; simp [mem_divisorsAntidiag] @[simp]	lemma	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	map_prodComm_divisorsAntidiag	null
map_neg_divisorsAntidiag : z.divisorsAntidiag.map (Equiv.neg _).toEmbedding = z.divisorsAntidiag := by ext; simp [mem_divisorsAntidiag, mul_comm]	lemma	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	map_neg_divisorsAntidiag	null
divisorsAntidiag_neg : (-z).divisorsAntidiag = z.divisorsAntidiag.map (.prodMap (.refl _) (Equiv.neg _).toEmbedding) := by ext; simp [mem_divisorsAntidiag, Prod.ext_iff, neg_eq_iff_eq_neg]	lemma	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	divisorsAntidiag_neg	null
divisorsAntidiag_natCast (n : ℕ) : divisorsAntidiag n = (n.divisorsAntidiagonal.map <\| .prodMap natCast natCast).disjUnion (n.divisorsAntidiagonal.map <\| .prodMap negNatCast negNatCast) (by simp +contextual [disjoint_left, eq_comm]) := rfl	lemma	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	divisorsAntidiag_natCast	null
divisorsAntidiag_neg_natCast (n : ℕ) : divisorsAntidiag (-n) = (n.divisorsAntidiagonal.map <\| .prodMap natCast negNatCast).disjUnion (n.divisorsAntidiagonal.map <\| .prodMap negNatCast natCast) (by simp +contextual [disjoint_left, eq_comm]) := by cases n <;> rfl	lemma	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	divisorsAntidiag_neg_natCast	null
divisorsAntidiag_ofNat (n : ℕ) : divisorsAntidiag ofNat(n) = (n.divisorsAntidiagonal.map <\| .prodMap natCast natCast).disjUnion (n.divisorsAntidiagonal.map <\| .prodMap negNatCast negNatCast) (by simp +contextual [disjoint_left, eq_comm]) := rfl	lemma	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	divisorsAntidiag_ofNat	null
mul_mem_one_two_three_iff {a b : ℤ} : a * b ∈ ({1, 2, 3} : Set ℤ) ↔ (a, b) ∈ ({ (1, 1), (-1, -1), (1, 2), (2, 1), (-1, -2), (-2, -1), (1, 3), (3, 1), (-1, -3), (-3, -1)} : Set (ℤ × ℤ)) := by simp only [← Int.prodMk_mem_divisorsAntidiag, Set.mem_insert_iff, Set.mem_singleton_iff, ne_eq, one_n...	lemma	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	mul_mem_one_two_three_iff	This lemma justifies its existence from its utility in crystallographic root system theory.
mul_mem_zero_one_two_three_four_iff {a b : ℤ} (h₀ : a = 0 ↔ b = 0) : a * b ∈ ({0, 1, 2, 3, 4} : Set ℤ) ↔ (a, b) ∈ ({ (0, 0), (1, 1), (-1, -1), (1, 2), (2, 1), (-1, -2), (-2, -1), (1, 3), (3, 1), (-1, -3), (-3, -1), (4, 1), (1, 4), (-4, -1), (-1, -4), (2, 2), (-2, -2)} : Set (ℤ × ℤ)) :=...	lemma	NumberTheory	[ "Mathlib.Algebra.IsPrimePow", "Mathlib.Algebra.Order.BigOperators.Group.Finset", "Mathlib.Algebra.Order.Interval.Finset.SuccPred", "Mathlib.Algebra.Order.Ring.Int", "Mathlib.Algebra.Ring.CharZero", "Mathlib.Data.Nat.Cast.Order.Ring", "Mathlib.Data.Nat.PrimeFin", "Mathlib.Data.Nat.SuccPred", "Mathlib...	Mathlib/NumberTheory/Divisors.lean	mul_mem_zero_one_two_three_four_iff	This lemma justifies its existence from its utility in crystallographic root system theory.
IsEllSequence : Prop := ∀ m n r : ℤ, W (m + n) * W (m - n) * W r ^ 2 = W (m + r) * W (m - r) * W n ^ 2 - W (n + r) * W (n - r) * W m ^ 2	def	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	IsEllSequence	The proposition that a sequence indexed by integers is an elliptic sequence.
IsDivSequence : Prop := ∀ m n : ℕ, m ∣ n → W m ∣ W n	def	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	IsDivSequence	The proposition that a sequence indexed by integers is a divisibility sequence.
IsEllDivSequence : Prop := IsEllSequence W ∧ IsDivSequence W	def	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	IsEllDivSequence	The proposition that a sequence indexed by integers is an EDS.
isEllSequence_id : IsEllSequence id := fun _ _ _ => by simp_rw [id_eq]; ring1	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	isEllSequence_id	null
isDivSequence_id : IsDivSequence id := fun _ _ => Int.ofNat_dvd.mpr	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	isDivSequence_id	null
isEllDivSequence_id : IsEllDivSequence id := ⟨isEllSequence_id, isDivSequence_id⟩ variable {W}	theorem	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	isEllDivSequence_id	The identity sequence is an EDS.
IsEllSequence.smul (h : IsEllSequence W) (x : R) : IsEllSequence (x • W) := fun m n r => by linear_combination (norm := (simp_rw [Pi.smul_apply, smul_eq_mul]; ring1)) x ^ 4 * h m n r	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	IsEllSequence.smul	null
IsDivSequence.smul (h : IsDivSequence W) (x : R) : IsDivSequence (x • W) := fun m n r => mul_dvd_mul_left x <\| h m n r	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	IsDivSequence.smul	null
IsEllDivSequence.smul (h : IsEllDivSequence W) (x : R) : IsEllDivSequence (x • W) := ⟨h.left.smul x, h.right.smul x⟩	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	IsEllDivSequence.smul	null
preNormEDS' : ℕ → R \| 0 => 0 \| 1 => 1 \| 2 => 1 \| 3 => c \| 4 => d \| (n + 5) => let m := n / 2 if hn : Even n then preNormEDS' (m + 4) * preNormEDS' (m + 2) ^ 3 * (if Even m then b else 1) - preNormEDS' (m + 1) * preNormEDS' (m + 3) ^ 3 * (if Even m then 1 else b) else have : m + 5...	def	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	preNormEDS'	The auxiliary sequence for a normalised EDS `W : ℕ → R`, with initial values `W(0) = 0`, `W(1) = 1`, `W(2) = 1`, `W(3) = c`, and `W(4) = d` and extra parameter `b`.
preNormEDS'_zero : preNormEDS' b c d 0 = 0 := by rw [preNormEDS'] @[simp]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	preNormEDS'_zero	null
preNormEDS'_one : preNormEDS' b c d 1 = 1 := by rw [preNormEDS'] @[simp]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	preNormEDS'_one	null
preNormEDS'_two : preNormEDS' b c d 2 = 1 := by rw [preNormEDS'] @[simp]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	preNormEDS'_two	null
preNormEDS'_three : preNormEDS' b c d 3 = c := by rw [preNormEDS'] @[simp]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	preNormEDS'_three	null
preNormEDS'_four : preNormEDS' b c d 4 = d := by rw [preNormEDS']	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	preNormEDS'_four	null
preNormEDS'_even (m : ℕ) : preNormEDS' b c d (2 * (m + 3)) = preNormEDS' b c d (m + 2) ^ 2 * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 5) - preNormEDS' b c d (m + 1) * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 4) ^ 2 := by rw [show 2 * (m + 3) = 2 * m + 1 + 5 by rfl, preNormEDS', dif_neg m...	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	preNormEDS'_even	null
preNormEDS'_odd (m : ℕ) : preNormEDS' b c d (2 * (m + 2) + 1) = preNormEDS' b c d (m + 4) * preNormEDS' b c d (m + 2) ^ 3 * (if Even m then b else 1) - preNormEDS' b c d (m + 1) * preNormEDS' b c d (m + 3) ^ 3 * (if Even m then 1 else b) := by rw [show 2 * (m + 2) + 1 = 2 * m + 5 by rfl, preNormEDS', dif_po...	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	preNormEDS'_odd	null
preNormEDS (n : ℤ) : R := n.sign * preNormEDS' b c d n.natAbs @[simp]	def	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	preNormEDS	The auxiliary sequence for a normalised EDS `W : ℤ → R`, with initial values `W(0) = 0`, `W(1) = 1`, `W(2) = 1`, `W(3) = c`, and `W(4) = d` and extra parameter `b`. This extends `preNormEDS'` by defining its values at negative integers.
preNormEDS_ofNat (n : ℕ) : preNormEDS b c d n = preNormEDS' b c d n := by by_cases hn : n = 0 · simp [hn, preNormEDS] · simp [preNormEDS, Int.sign_natCast_of_ne_zero hn] @[simp]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	preNormEDS_ofNat	null
preNormEDS_zero : preNormEDS b c d 0 = 0 := by simp [preNormEDS] @[simp]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	preNormEDS_zero	null
preNormEDS_one : preNormEDS b c d 1 = 1 := by simp [preNormEDS] @[simp]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	preNormEDS_one	null
preNormEDS_two : preNormEDS b c d 2 = 1 := by simp [preNormEDS, Int.sign_eq_one_of_pos] @[simp]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	preNormEDS_two	null
preNormEDS_three : preNormEDS b c d 3 = c := by simp [preNormEDS, Int.sign_eq_one_of_pos] @[simp]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	preNormEDS_three	null
preNormEDS_four : preNormEDS b c d 4 = d := by simp [preNormEDS, Int.sign_eq_one_of_pos] @[simp]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	preNormEDS_four	null
preNormEDS_neg (n : ℤ) : preNormEDS b c d (-n) = -preNormEDS b c d n := by simp [preNormEDS]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	preNormEDS_neg	null
preNormEDS_even (m : ℤ) : preNormEDS b c d (2 * m) = preNormEDS b c d (m - 1) ^ 2 * preNormEDS b c d m * preNormEDS b c d (m + 2) - preNormEDS b c d (m - 2) * preNormEDS b c d m * preNormEDS b c d (m + 1) ^ 2 := by induction m using Int.negInduction with \| nat m => rcases m with _ \| _ \| _ \| m iter...	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	preNormEDS_even	null
preNormEDS_odd (m : ℤ) : preNormEDS b c d (2 * m + 1) = preNormEDS b c d (m + 2) * preNormEDS b c d m ^ 3 * (if Even m then b else 1) - preNormEDS b c d (m - 1) * preNormEDS b c d (m + 1) ^ 3 * (if Even m then 1 else b) := by induction m using Int.negInduction with \| nat m => rcases m with _ \| _ \| _ ...	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	preNormEDS_odd	null
complEDS₂ (k : ℤ) : R := (preNormEDS (b ^ 4) c d (k - 1) ^ 2 * preNormEDS (b ^ 4) c d (k + 2) - preNormEDS (b ^ 4) c d (k - 2) * preNormEDS (b ^ 4) c d (k + 1) ^ 2) * if Even k then 1 else b @[simp]	def	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	complEDS₂	The 2-complement sequence `Wᶜ₂ : ℤ → R` for a normalised EDS `W : ℤ → R` that witnesses `W(k) ∣ W(2 * k)`. In other words, `W(k) * Wᶜ₂(k) = W(2 * k)` for any `k ∈ ℤ`. This is defined in terms of `preNormEDS`.
complEDS₂_zero : complEDS₂ b c d 0 = 2 := by simp [complEDS₂, one_add_one_eq_two] @[simp]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	complEDS₂_zero	null
complEDS₂_one : complEDS₂ b c d 1 = b := by simp [complEDS₂] @[simp]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	complEDS₂_one	null
complEDS₂_two : complEDS₂ b c d 2 = d := by simp [complEDS₂] @[simp]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	complEDS₂_two	null
complEDS₂_three : complEDS₂ b c d 3 = preNormEDS (b ^ 4) c d 5 * b - d ^ 2 * b := by simp [complEDS₂, if_neg (by decide : ¬Even (3 : ℤ)), sub_mul] @[simp]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	complEDS₂_three	null
complEDS₂_four : complEDS₂ b c d 4 = c ^ 2 * preNormEDS (b ^ 4) c d 6 - preNormEDS (b ^ 4) c d 5 ^ 2 := by simp [complEDS₂, if_pos (by decide : Even (4 : ℤ))] @[simp]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	complEDS₂_four	null
complEDS₂_neg (k : ℤ) : complEDS₂ b c d (-k) = complEDS₂ b c d k := by simp_rw [complEDS₂, ← neg_add', ← sub_neg_eq_add, ← neg_sub', preNormEDS_neg, even_neg] ring1	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	complEDS₂_neg	null
preNormEDS_mul_complEDS₂ (k : ℤ) : preNormEDS (b ^ 4) c d k * complEDS₂ b c d k = preNormEDS (b ^ 4) c d (2 * k) * if Even k then 1 else b := by rw [complEDS₂, preNormEDS_even] ring1	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	preNormEDS_mul_complEDS₂	null
normEDS (n : ℤ) : R := preNormEDS (b ^ 4) c d n * if Even n then b else 1 @[simp]	def	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	normEDS	The canonical example of a normalised EDS `W : ℤ → R`, with initial values `W(0) = 0`, `W(1) = 1`, `W(2) = b`, `W(3) = c`, and `W(4) = d * b`. This is defined in terms of `preNormEDS` whose even terms differ by a factor of `b`.
normEDS_ofNat (n : ℕ) : normEDS b c d n = preNormEDS' (b ^ 4) c d n * if Even n then b else 1 := by simp [normEDS] @[simp]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	normEDS_ofNat	null
normEDS_zero : normEDS b c d 0 = 0 := by simp [normEDS] @[simp]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	normEDS_zero	null
normEDS_one : normEDS b c d 1 = 1 := by simp [normEDS] @[simp]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	normEDS_one	null
normEDS_two : normEDS b c d 2 = b := by simp [normEDS] @[simp]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	normEDS_two	null
normEDS_three : normEDS b c d 3 = c := by simp [normEDS, show ¬Even (3 : ℤ) by decide] @[simp]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	normEDS_three	null
normEDS_four : normEDS b c d 4 = d * b := by simp [normEDS, show ¬Odd (4 : ℤ) by decide] @[simp]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	normEDS_four	null
normEDS_neg (n : ℤ) : normEDS b c d (-n) = -normEDS b c d n := by simp_rw [normEDS, preNormEDS_neg, even_neg, neg_mul]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	normEDS_neg	null
normEDS_mul_complEDS₂ (k : ℤ) : normEDS b c d k * complEDS₂ b c d k = normEDS b c d (2 * k) := by simp_rw [normEDS, mul_right_comm, preNormEDS_mul_complEDS₂, mul_assoc, apply_ite₂, one_mul, mul_one, ite_self, if_pos <\| even_two_mul k]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	normEDS_mul_complEDS₂	null
normEDS_dvd_normEDS_two_mul (k : ℤ) : normEDS b c d k ∣ normEDS b c d (2 * k) := ⟨complEDS₂ .., (normEDS_mul_complEDS₂ ..).symm⟩	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	normEDS_dvd_normEDS_two_mul	null
complEDS₂_mul_b (k : ℤ) : complEDS₂ b c d k * b = normEDS b c d (k - 1) ^ 2 * normEDS b c d (k + 2) - normEDS b c d (k - 2) * normEDS b c d (k + 1) ^ 2 := by induction k using Int.negInduction with \| nat k => simp_rw [complEDS₂, normEDS, Int.even_add, Int.even_sub, even_two, iff_true, Int.not_even_one...	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	complEDS₂_mul_b	null
normEDS_even (m : ℤ) : normEDS b c d (2 * m) * b = normEDS b c d (m - 1) ^ 2 * normEDS b c d m * normEDS b c d (m + 2) - normEDS b c d (m - 2) * normEDS b c d m * normEDS b c d (m + 1) ^ 2 := by rw [← normEDS_mul_complEDS₂, mul_assoc, complEDS₂_mul_b] ring1 @[deprecated (since := "2025-05-15")] alias norm...	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	normEDS_even	null
normEDS_odd (m : ℤ) : normEDS b c d (2 * m + 1) = normEDS b c d (m + 2) * normEDS b c d m ^ 3 - normEDS b c d (m - 1) * normEDS b c d (m + 1) ^ 3 := by simp_rw [normEDS, preNormEDS_odd, if_neg m.not_even_two_mul_add_one, Int.even_add, Int.even_sub, even_two, iff_true, Int.not_even_one, iff_false] spli...	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	normEDS_odd	null
@[elab_as_elim] noncomputable normEDSRec' {P : ℕ → Sort u} (zero : P 0) (one : P 1) (two : P 2) (three : P 3) (four : P 4) (even : ∀ m : ℕ, (∀ k < 2 * (m + 3), P k) → P (2 * (m + 3))) (odd : ∀ m : ℕ, (∀ k < 2 * (m + 2) + 1, P k) → P (2 * (m + 2) + 1)) (n : ℕ) : P n := n.evenOddStrongRec (by rintro (_ \| _ ...	def	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	normEDSRec'	Strong recursion principle for a normalised EDS: if we have * `P 0`, `P 1`, `P 2`, `P 3`, and `P 4`, * for all `m : ℕ` we can prove `P (2 * (m + 3))` from `P k` for all `k < 2 * (m + 3)`, and * for all `m : ℕ` we can prove `P (2 * (m + 2) + 1)` from `P k` for all `k < 2 * (m + 2) + 1`, then we have `P n` for all `n :...
@[elab_as_elim] noncomputable normEDSRec {P : ℕ → Sort u} (zero : P 0) (one : P 1) (two : P 2) (three : P 3) (four : P 4) (even : ∀ m : ℕ, P (m + 1) → P (m + 2) → P (m + 3) → P (m + 4) → P (m + 5) → P (2 * (m + 3))) (odd : ∀ m : ℕ, P (m + 1) → P (m + 2) → P (m + 3) → P (m + 4) → P (2 * (m + 2) + 1)) (n : ℕ)...	def	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	normEDSRec	Recursion principle for a normalised EDS: if we have * `P 0`, `P 1`, `P 2`, `P 3`, and `P 4`, * for all `m : ℕ` we can prove `P (2 * (m + 3))` from `P (m + 1)`, `P (m + 2)`, `P (m + 3)`, `P (m + 4)`, and `P (m + 5)`, and * for all `m : ℕ` we can prove `P (2 * (m + 2) + 1)` from `P (m + 1)`, `P (m + 2)`, `P (m + 3)`, ...
complEDS' : ℕ → R \| 0 => 0 \| 1 => 1 \| (n + 2) => let m := n / 2 + 1 if hn : Even n then complEDS' m * complEDS₂ b c d (m * k) else have : m + 1 < n + 2 := add_lt_add_right (Nat.div_lt_self (Nat.not_even_iff_odd.mp hn).pos one_lt_two) 2 complEDS' m ^ 2 * normEDS b c d ((m + 1) * k + 1) * no...	def	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	complEDS'	The complement sequence `Wᶜ : ℤ × ℕ → R` for a normalised EDS `W : ℤ → R` that witnesses `W(k) ∣ W(n * k)`. In other words, `W(k) * Wᶜ(k, n) = W(n * k)` for any `k, n ∈ ℤ`. This is defined in terms of `normEDS` and agrees with `complEDS₂` when `n = 2`.
complEDS'_zero : complEDS' b c d k 0 = 0 := by rw [complEDS'] @[simp]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	complEDS'_zero	null
complEDS'_one : complEDS' b c d k 1 = 1 := by rw [complEDS']	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	complEDS'_one	null
complEDS'_even (m : ℕ) : complEDS' b c d k (2 * (m + 1)) = complEDS' b c d k (m + 1) * complEDS₂ b c d ((m + 1) * k) := by rw [show 2 * (m + 1) = 2 * m + 2 by rfl, complEDS', dif_pos <\| even_two_mul m, m.mul_div_cancel_left two_pos, Nat.cast_succ]	lemma	NumberTheory	[ "Mathlib.Data.Nat.EvenOddRec", "Mathlib.Tactic.Linarith", "Mathlib.Tactic.LinearCombination" ]	Mathlib/NumberTheory/EllipticDivisibilitySequence.lean	complEDS'_even	null

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.