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 {α β} (f : α → β) (g : Poly α) : Poly β :=
⟨fun v => g <| v ∘ f, Poly.induction (C := fun g => IsPoly (fun v => g (v ∘ f)))
(fun i => by simpa using IsPoly.proj _) (fun n => by simpa using IsPoly.const _)
(fun f g pf pg => by simpa using IsPoly.sub pf pg)
(fun f g pf pg => by simpa using IsPoly.mul pf... | def | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | map | Map the index set of variables, replacing `x_i` with `x_(f i)`. |
map_apply {α β} (f : α → β) (g : Poly α) (v) : map f g v = g (v ∘ f) := rfl | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | map_apply | null |
Dioph {α : Type u} (S : Set (α → ℕ)) : Prop :=
∃ (β : Type u) (p : Poly (α ⊕ β)), ∀ v, S v ↔ ∃ t, p (v ⊗ t) = 0 | def | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | Dioph | A set `S ⊆ ℕ^α` is Diophantine if there exists a polynomial on
`α ⊕ β` such that `v ∈ S` iff there exists `t : ℕ^β` with `p (v, t) = 0`. |
ext (d : Dioph S) (H : ∀ v, v ∈ S ↔ v ∈ S') : Dioph S' := by rwa [← Set.ext H] | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | ext | null |
of_no_dummies (S : Set (α → ℕ)) (p : Poly α) (h : ∀ v, S v ↔ p v = 0) : Dioph S :=
⟨PEmpty, ⟨p.map inl, fun v => (h v).trans ⟨fun h => ⟨PEmpty.elim, h⟩, fun ⟨_, ht⟩ => ht⟩⟩⟩ | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | of_no_dummies | null |
inject_dummies_lem (f : β → γ) (g : γ → Option β) (inv : ∀ x, g (f x) = some x)
(p : Poly (α ⊕ β)) (v : α → ℕ) :
(∃ t, p (v ⊗ t) = 0) ↔ ∃ t, p.map (inl ⊗ inr ∘ f) (v ⊗ t) = 0 := by
dsimp; refine ⟨fun t => ?_, fun t => ?_⟩ <;> obtain ⟨t, ht⟩ := t
· have : (v ⊗ (0 ::ₒ t) ∘ g) ∘ (inl ⊗ inr ∘ f) = v ⊗ t :=
... | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | inject_dummies_lem | null |
inject_dummies (f : β → γ) (g : γ → Option β) (inv : ∀ x, g (f x) = some x)
(p : Poly (α ⊕ β)) (h : ∀ v, S v ↔ ∃ t, p (v ⊗ t) = 0) :
∃ q : Poly (α ⊕ γ), ∀ v, S v ↔ ∃ t, q (v ⊗ t) = 0 :=
⟨p.map (inl ⊗ inr ∘ f), fun v => (h v).trans <| inject_dummies_lem f g inv _ _⟩
variable (β) in | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | inject_dummies | null |
reindex_dioph (f : α → β) : Dioph S → Dioph {v | v ∘ f ∈ S}
| ⟨γ, p, pe⟩ => ⟨γ, p.map (inl ∘ f ⊗ inr), fun v =>
(pe _).trans <|
exists_congr fun t =>
suffices v ∘ f ⊗ t = (v ⊗ t) ∘ (inl ∘ f ⊗ inr) by simp [this]
funext fun s => by rcases s with a | b <;> rfl⟩ | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | reindex_dioph | null |
DiophList.forall (l : List (Set <| α → ℕ)) (d : l.Forall Dioph) :
Dioph {v | l.Forall fun S : Set (α → ℕ) => v ∈ S} := by
suffices ∃ (β : _) (pl : List (Poly (α ⊕ β))), ∀ v, List.Forall (fun S : Set _ => S v) l ↔
∃ t, List.Forall (fun p : Poly (α ⊕ β) => p (v ⊗ t) = 0) pl
from
let ⟨β, pl, h⟩ := ... | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | DiophList.forall | null |
inter (d : Dioph S) (d' : Dioph S') : Dioph (S ∩ S') := DiophList.forall [S, S'] ⟨d, d'⟩ | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | inter | Diophantine sets are closed under intersection. |
union : ∀ (_ : Dioph S) (_ : Dioph S'), Dioph (S ∪ S')
| ⟨β, p, pe⟩, ⟨γ, q, qe⟩ =>
⟨β ⊕ γ, p.map (inl ⊗ inr ∘ inl) * q.map (inl ⊗ inr ∘ inr), fun v => by
refine
Iff.trans (or_congr ((pe v).trans ?_) ((qe v).trans ?_))
(exists_or.symm.trans
(exists_congr fun t =>
(... | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | union | Diophantine sets are closed under union. |
DiophPFun (f : (α → ℕ) →. ℕ) : Prop :=
Dioph {v : Option α → ℕ | f.graph (v ∘ some, v none)} | def | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | DiophPFun | A partial function is Diophantine if its graph is Diophantine. |
DiophFn (f : (α → ℕ) → ℕ) : Prop :=
Dioph {v : Option α → ℕ | f (v ∘ some) = v none} | def | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | DiophFn | A function is Diophantine if its graph is Diophantine. |
reindex_diophFn {f : (α → ℕ) → ℕ} (g : α → β) (d : DiophFn f) :
DiophFn fun v => f (v ∘ g) := by convert reindex_dioph (Option β) (Option.map g) d | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | reindex_diophFn | null |
ex_dioph {S : Set (α ⊕ β → ℕ)} : Dioph S → Dioph {v | ∃ x, v ⊗ x ∈ S}
| ⟨γ, p, pe⟩ =>
⟨β ⊕ γ, p.map ((inl ⊗ inr ∘ inl) ⊗ inr ∘ inr), fun v =>
⟨fun ⟨x, hx⟩ =>
let ⟨t, ht⟩ := (pe _).1 hx
⟨x ⊗ t, by
simp only [Poly.map_apply]
rw [show (v ⊗ x ⊗ t) ∘ ((inl ⊗ inr ∘ inl) ⊗ inr ∘... | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | ex_dioph | null |
ex1_dioph {S : Set (Option α → ℕ)} : Dioph S → Dioph {v | ∃ x, x ::ₒ v ∈ S}
| ⟨β, p, pe⟩ =>
⟨Option β, p.map (inr none ::ₒ inl ⊗ inr ∘ some), fun v =>
⟨fun ⟨x, hx⟩ =>
let ⟨t, ht⟩ := (pe _).1 hx
⟨x ::ₒ t, by
simp only [Poly.map_apply]
rw [show (v ⊗ x ::ₒ t) ∘ (inr none ::ₒ... | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | ex1_dioph | null |
dom_dioph {f : (α → ℕ) →. ℕ} (d : DiophPFun f) : Dioph f.Dom :=
cast (congr_arg Dioph <| Set.ext fun _ => (PFun.dom_iff_graph _ _).symm) (ex1_dioph d) | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | dom_dioph | null |
diophFn_iff_pFun (f : (α → ℕ) → ℕ) : DiophFn f = @DiophPFun α f := by
refine congr_arg Dioph (Set.ext fun v => ?_); exact PFun.lift_graph.symm | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | diophFn_iff_pFun | null |
abs_poly_dioph (p : Poly α) : DiophFn fun v => (p v).natAbs :=
of_no_dummies _ ((p.map some - Poly.proj none) * (p.map some + Poly.proj none))
fun v => (by dsimp; exact Int.natAbs_eq_iff_mul_eq_zero) | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | abs_poly_dioph | null |
proj_dioph (i : α) : DiophFn fun v => v i :=
abs_poly_dioph (Poly.proj i) | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | proj_dioph | null |
diophPFun_comp1 {S : Set (Option α → ℕ)} (d : Dioph S) {f} (df : DiophPFun f) :
Dioph {v : α → ℕ | ∃ h : f.Dom v, f.fn v h ::ₒ v ∈ S} :=
ext (ex1_dioph (d.inter df)) fun v =>
⟨fun ⟨x, hS, (h : Exists _)⟩ => by
rw [show (x ::ₒ v) ∘ some = v from funext fun s => rfl] at h
obtain ⟨hf, h⟩ := h; refine... | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | diophPFun_comp1 | null |
diophFn_comp1 {S : Set (Option α → ℕ)} (d : Dioph S) {f : (α → ℕ) → ℕ} (df : DiophFn f) :
Dioph {v | f v ::ₒ v ∈ S} :=
ext (diophPFun_comp1 d <| cast (diophFn_iff_pFun f) df)
fun _ => ⟨fun ⟨_, h⟩ => h, fun h => ⟨trivial, h⟩⟩ | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | diophFn_comp1 | null |
diophFn_vec_comp1 {S : Set (Vector3 ℕ (succ n))} (d : Dioph S) {f : Vector3 ℕ n → ℕ}
(df : DiophFn f) : Dioph {v : Vector3 ℕ n | (f v::v) ∈ S} :=
Dioph.ext (diophFn_comp1 (reindex_dioph _ (none::some) d) df) (fun v => by
dsimp
apply iff_of_eq
congr 1
ext x; cases x <;> rfl) | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | diophFn_vec_comp1 | null |
vec_ex1_dioph (n) {S : Set (Vector3 ℕ (succ n))} (d : Dioph S) :
Dioph {v : Fin2 n → ℕ | ∃ x, (x::v) ∈ S} :=
ext (ex1_dioph <| reindex_dioph _ (none::some) d) fun v =>
exists_congr fun x => by
dsimp
rw [show Option.elim' x v ∘ cons none some = x::v from
funext fun s => by rcases s with a... | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | vec_ex1_dioph | Deleting the first component preserves the Diophantine property. |
diophFn_vec (f : Vector3 ℕ n → ℕ) : DiophFn f ↔ Dioph {v | f (v ∘ fs) = v fz} :=
⟨reindex_dioph _ (fz ::ₒ fs), reindex_dioph _ (none::some)⟩ | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | diophFn_vec | null |
diophPFun_vec (f : Vector3 ℕ n →. ℕ) : DiophPFun f ↔ Dioph {v | f.graph (v ∘ fs, v fz)} :=
⟨reindex_dioph _ (fz ::ₒ fs), reindex_dioph _ (none::some)⟩ | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | diophPFun_vec | null |
diophFn_compn :
∀ {n} {S : Set (α ⊕ (Fin2 n) → ℕ)} (_ : Dioph S) {f : Vector3 ((α → ℕ) → ℕ) n}
(_ : VectorAllP DiophFn f), Dioph {v : α → ℕ | (v ⊗ fun i => f i v) ∈ S}
| 0, S, d, f => fun _ =>
ext (reindex_dioph _ (id ⊗ Fin2.elim0) d) fun v => by
dsimp
congr! 1
ext x; obtain _ | _ | _ ... | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | diophFn_compn | null |
dioph_comp {S : Set (Vector3 ℕ n)} (d : Dioph S) (f : Vector3 ((α → ℕ) → ℕ) n)
(df : VectorAllP DiophFn f) : Dioph {v | (fun i => f i v) ∈ S} :=
diophFn_compn (reindex_dioph _ inr d) df | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | dioph_comp | null |
diophFn_comp {f : Vector3 ℕ n → ℕ} (df : DiophFn f) (g : Vector3 ((α → ℕ) → ℕ) n)
(dg : VectorAllP DiophFn g) : DiophFn fun v => f fun i => g i v :=
dioph_comp ((diophFn_vec _).1 df) ((fun v => v none)::fun i v => g i (v ∘ some)) <| by
simp only [vectorAllP_cons]
exact ⟨proj_dioph none, (vectorAllP_iff_fo... | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | diophFn_comp | null |
eq_dioph : Dioph fun v => f v = g v :=
dioph_comp2 df dg <|
of_no_dummies _ (Poly.proj &0 - Poly.proj &1) fun v => by
exact Int.ofNat_inj.symm.trans ⟨@sub_eq_zero_of_eq ℤ _ (v &0) (v &1), eq_of_sub_eq_zero⟩
@[inherit_doc]
scoped infixl:50 " D= " => Dioph.eq_dioph | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | eq_dioph | Local abbreviation for `Fin2.ofNat'` -/
scoped prefix:arg "&" => Fin2.ofNat'
theorem proj_dioph_of_nat {n : ℕ} (m : ℕ) [IsLT m n] : DiophFn fun v : Vector3 ℕ n => v &m :=
proj_dioph &m
/-- Projection preserves Diophantine functions. -/
scoped prefix:100 "D&" => Dioph.proj_dioph_of_nat
theorem const_dioph (n : ℕ) :... |
add_dioph : DiophFn fun v => f v + g v :=
diophFn_comp2 df dg <| abs_poly_dioph (@Poly.proj (Fin2 2) &0 + @Poly.proj (Fin2 2) &1)
@[inherit_doc]
scoped infixl:80 " D+ " => Dioph.add_dioph | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | add_dioph | Diophantine functions are closed under addition. |
mul_dioph : DiophFn fun v => f v * g v :=
diophFn_comp2 df dg <| abs_poly_dioph (@Poly.proj (Fin2 2) &0 * @Poly.proj (Fin2 2) &1)
@[inherit_doc]
scoped infixl:90 " D* " => Dioph.mul_dioph | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | mul_dioph | Diophantine functions are closed under multiplication. |
le_dioph : Dioph {v | f v ≤ g v} :=
dioph_comp2 df dg <|
ext ((D∃) 2 <| D&1 D+ D&0 D= D&2) fun _ => ⟨fun ⟨_, hx⟩ => le.intro hx, le.dest⟩
@[inherit_doc]
scoped infixl:50 " D≤ " => Dioph.le_dioph | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | le_dioph | The set of places where one Diophantine function is at most another is Diophantine. |
lt_dioph : Dioph {v | f v < g v} := df D+ D.1 D≤ dg
@[inherit_doc]
scoped infixl:50 " D< " => Dioph.lt_dioph | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | lt_dioph | The set of places where one Diophantine function is less than another is Diophantine. |
ne_dioph : Dioph {v | f v ≠ g v} :=
ext (df D< dg D∨ dg D< df) fun v => by dsimp; exact lt_or_lt_iff_ne (α := ℕ)
@[inherit_doc]
scoped infixl:50 " D≠ " => Dioph.ne_dioph | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | ne_dioph | The set of places where two Diophantine functions are unequal is Diophantine. |
sub_dioph : DiophFn fun v => f v - g v :=
diophFn_comp2 df dg <|
(diophFn_vec _).2 <|
ext (D&1 D= D&0 D+ D&2 D∨ D&1 D≤ D&2 D∧ D&0 D= D.0) <|
(vectorAll_iff_forall _).1 fun x y z =>
show y = x + z ∨ y ≤ z ∧ x = 0 ↔ y - z = x from
⟨fun o => by
rcases o with (ae | ⟨y... | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | sub_dioph | Diophantine functions are closed under subtraction. |
dvd_dioph : Dioph fun v => f v ∣ g v :=
dioph_comp ((D∃) 2 <| D&2 D= D&1 D* D&0) [f, g] ⟨df, dg⟩
@[inherit_doc]
scoped infixl:50 " D∣ " => Dioph.dvd_dioph | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | dvd_dioph | The set of places where one Diophantine function divides another is Diophantine. |
mod_dioph : DiophFn fun v => f v % g v :=
have : Dioph fun v : Vector3 ℕ 3 => (v &2 = 0 ∨ v &0 < v &2) ∧ ∃ x : ℕ, v &0 + v &2 * x = v &1 :=
(D&2 D= D.0 D∨ D&0 D< D&2) D∧ (D∃) 3 <| D&1 D+ D&3 D* D&0 D= D&2
diophFn_comp2 df dg <|
(diophFn_vec _).2 <|
ext this <|
(vectorAll_iff_forall _).1 fun z ... | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | mod_dioph | Diophantine functions are closed under the modulo operation. |
modEq_dioph {h : (α → ℕ) → ℕ} (dh : DiophFn h) : Dioph fun v => f v ≡ g v [MOD h v] :=
df D% dh D= dg D% dh
@[inherit_doc]
scoped notation " D≡ " => Dioph.modEq_dioph | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | modEq_dioph | The set of places where two Diophantine functions are congruent modulo a third
is Diophantine. |
div_dioph : DiophFn fun v => f v / g v :=
have :
Dioph fun v : Vector3 ℕ 3 =>
v &2 = 0 ∧ v &0 = 0 ∨ v &0 * v &2 ≤ v &1 ∧ v &1 < (v &0 + 1) * v &2 :=
(D&2 D= D.0 D∧ D&0 D= D.0) D∨ D&0 D* D&2 D≤ D&1 D∧ D&1 D< (D&0 D+ D.1) D* D&2
diophFn_comp2 df dg <|
(diophFn_vec _).2 <|
ext this <|
(... | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | div_dioph | Diophantine functions are closed under integer division. |
pell_dioph :
Dioph fun v : Vector3 ℕ 4 => ∃ h : 1 < v &0, xn h (v &1) = v &2 ∧ yn h (v &1) = v &3 := by
have : Dioph {v : Vector3 ℕ 4 |
1 < v &0 ∧ v &1 ≤ v &3 ∧
(v &2 = 1 ∧ v &3 = 0 ∨
∃ u w s t b : ℕ,
v &2 * v &2 - (v &0 * v &0 - 1) * v &3 * v &3 = 1 ∧
u * u - (v &0 * v &0 - 1) * w * w = 1... | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | pell_dioph | null |
xn_dioph : DiophPFun fun v : Vector3 ℕ 2 => ⟨1 < v &0, fun h => xn h (v &1)⟩ :=
have : Dioph fun v : Vector3 ℕ 3 => ∃ y, ∃ h : 1 < v &1, xn h (v &2) = v &0 ∧ yn h (v &2) = y :=
let D_pell := pell_dioph.reindex_dioph (Fin2 4) [&2, &3, &1, &0]
(D∃) 3 D_pell
(diophPFun_vec _).2 <|
Dioph.ext this fun _ => ⟨... | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | xn_dioph | null |
pow_dioph {f g : (α → ℕ) → ℕ} (df : DiophFn f) (dg : DiophFn g) :
DiophFn fun v => f v ^ g v := by
have : Dioph {v : Vector3 ℕ 3 |
v &2 = 0 ∧ v &0 = 1 ∨ 0 < v &2 ∧
(v &1 = 0 ∧ v &0 = 0 ∨ 0 < v &1 ∧
∃ w a t z x y : ℕ,
(∃ a1 : 1 < a, xn a1 (v &2) = x ∧ yn a1 (v &2) = y) ∧
x ≡ y * (a - v &1) ... | theorem | NumberTheory | [
"Mathlib.Data.Fin.Fin2",
"Mathlib.Data.PFun",
"Mathlib.Data.Vector3",
"Mathlib.NumberTheory.PellMatiyasevic"
] | Mathlib/NumberTheory/Dioph.lean | pow_dioph | A version of **Matiyasevic's theorem** |
divisors : Finset ℕ := {d ∈ Ico 1 (n + 1) | d ∣ 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 | divisors | `divisors n` is the `Finset` of divisors of `n`. By convention, we set `divisors 0 = ∅`. |
properDivisors : Finset ℕ := {d ∈ Ico 1 n | d ∣ 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 | properDivisors | `properDivisors n` is the `Finset` of divisors of `n`, other than `n`.
By convention, we set `properDivisors 0 = ∅`. |
divisorsAntidiagonal : Finset (ℕ × ℕ) :=
(Icc 1 n).filterMap (fun x ↦ let y := n / x; if x * y = n then some (x, y) else none)
fun x₁ x₂ (x, y) hx₁ hx₂ ↦ by aesop | 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 | divisorsAntidiagonal | Pairs of divisors of a natural number as a finset.
`n.divisorsAntidiagonal` is the finset of pairs `(a, b) : ℕ × ℕ` such that `a * b = n`.
By convention, we set `Nat.divisorsAntidiagonal 0 = ∅`.
O(n). |
divisorsAntidiagonalList (n : ℕ) : List (ℕ × ℕ) :=
(List.range' 1 n).filterMap
(fun x ↦ let y := n / x; if x * y = n then some (x, y) else none)
variable {n}
@[simp] | 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 | divisorsAntidiagonalList | Pairs of divisors of a natural number, as a list.
`n.divisorsAntidiagonalList` is the list of pairs `(a, b) : ℕ × ℕ` such that `a * b = n`, ordered
by increasing `a`. By convention, we set `Nat.divisorsAntidiagonalList 0 = []`. |
filter_dvd_eq_divisors (h : n ≠ 0) : {d ∈ range n.succ | d ∣ n} = n.divisors := by
ext
simp only [divisors, mem_filter, mem_range, mem_Ico, and_congr_left_iff, iff_and_self]
exact fun ha _ => succ_le_iff.mpr (pos_of_dvd_of_pos ha h.bot_lt)
@[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 | filter_dvd_eq_divisors | null |
filter_dvd_eq_properDivisors (h : n ≠ 0) : {d ∈ range n | d ∣ n} = n.properDivisors := by
ext
simp only [properDivisors, mem_filter, mem_range, mem_Ico, and_congr_left_iff, iff_and_self]
exact fun ha _ => succ_le_iff.mpr (pos_of_dvd_of_pos ha h.bot_lt) | 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 | filter_dvd_eq_properDivisors | null |
self_notMem_properDivisors : n ∉ properDivisors n := by simp [properDivisors]
@[deprecated (since := "2025-05-23")]
alias properDivisors.not_self_mem := self_notMem_properDivisors
@[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 | self_notMem_properDivisors | null |
mem_properDivisors {m : ℕ} : n ∈ properDivisors m ↔ n ∣ m ∧ n < m := by
rcases eq_or_ne m 0 with (rfl | hm); · simp [properDivisors]
simp only [and_comm, ← filter_dvd_eq_properDivisors hm, mem_filter, mem_range] | 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 | null |
insert_self_properDivisors (h : n ≠ 0) : insert n (properDivisors n) = divisors n := by
rw [divisors, properDivisors,
← Finset.insert_Ico_right_eq_Ico_add_one (one_le_iff_ne_zero.2 h),
Finset.filter_insert, if_pos (dvd_refl n)] | 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 | insert_self_properDivisors | null |
cons_self_properDivisors (h : n ≠ 0) :
cons n (properDivisors n) self_notMem_properDivisors = divisors n := by
rw [cons_eq_insert, insert_self_properDivisors h]
@[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 | cons_self_properDivisors | null |
mem_divisors {m : ℕ} : n ∈ divisors m ↔ n ∣ m ∧ m ≠ 0 := by
rcases eq_or_ne m 0 with (rfl | hm); · simp [divisors]
simp only [hm, Ne, not_false_iff, and_true, ← filter_dvd_eq_divisors hm, mem_filter,
mem_range, and_iff_right_iff_imp, Nat.lt_succ_iff]
exact le_of_dvd hm.bot_lt | 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 | null |
dvd_of_mem_divisors {m : ℕ} (h : n ∈ divisors m) : n ∣ m := (mem_divisors.mp h).1 | 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 | dvd_of_mem_divisors | null |
ne_zero_of_mem_divisors {m : ℕ} (h : n ∈ divisors m) : m ≠ 0 := (mem_divisors.mp h).2 | 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 | ne_zero_of_mem_divisors | null |
one_mem_divisors : 1 ∈ divisors n ↔ n ≠ 0 := by 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 | one_mem_divisors | null |
mem_divisors_self (n : ℕ) (h : n ≠ 0) : n ∈ n.divisors :=
mem_divisors.2 ⟨dvd_rfl, h⟩
@[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 | mem_divisors_self | null |
mem_divisorsAntidiagonal {x : ℕ × ℕ} :
x ∈ divisorsAntidiagonal n ↔ x.fst * x.snd = n ∧ n ≠ 0 := by
obtain ⟨a, b⟩ := x
simp only [divisorsAntidiagonal, mul_div_eq_iff_dvd, mem_filterMap, mem_Icc, one_le_iff_ne_zero,
Option.ite_none_right_eq_some, Option.some.injEq, Prod.ext_iff, and_left_comm, exists_eq_lef... | 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_divisorsAntidiagonal | null |
toFinset_divisorsAntidiagonalList {n : ℕ} :
n.divisorsAntidiagonalList.toFinset = n.divisorsAntidiagonal := by
rw [divisorsAntidiagonalList, divisorsAntidiagonal, List.toFinset_filterMap
(f_inj := by simp_all), List.toFinset_range'_1_1] | 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 | toFinset_divisorsAntidiagonalList | null |
sorted_divisorsAntidiagonalList_fst {n : ℕ} :
n.divisorsAntidiagonalList.Sorted (·.fst < ·.fst) := by
refine (List.sorted_lt_range' _ _ Nat.one_ne_zero).filterMap fun a b c d h h' ha => ?_
rw [Option.ite_none_right_eq_some, Option.some.injEq] at h h'
simpa [← h.right, ← h'.right] | 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 | sorted_divisorsAntidiagonalList_fst | null |
sorted_divisorsAntidiagonalList_snd {n : ℕ} :
n.divisorsAntidiagonalList.Sorted (·.snd > ·.snd) := by
obtain rfl | hn := eq_or_ne n 0
· simp
refine (List.sorted_lt_range' _ _ Nat.one_ne_zero).filterMap ?_
simp only [Option.ite_none_right_eq_some, Option.some.injEq, gt_iff_lt, and_imp, Prod.forall,
Prod.... | 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 | sorted_divisorsAntidiagonalList_snd | null |
nodup_divisorsAntidiagonalList {n : ℕ} : n.divisorsAntidiagonalList.Nodup :=
have : IsIrrefl (ℕ × ℕ) (·.fst < ·.fst) := ⟨by simp⟩
sorted_divisorsAntidiagonalList_fst.nodup | 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 | nodup_divisorsAntidiagonalList | null |
@[simp]
val_divisorsAntidiagonal (n : ℕ) :
(divisorsAntidiagonal n).val = divisorsAntidiagonalList n :=
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 | val_divisorsAntidiagonal | The `Finset` and `List` versions agree by definition. |
mem_divisorsAntidiagonalList {n : ℕ} {a : ℕ × ℕ} :
a ∈ n.divisorsAntidiagonalList ↔ a.1 * a.2 = n ∧ n ≠ 0 := by
rw [← List.mem_toFinset, toFinset_divisorsAntidiagonalList, mem_divisorsAntidiagonal]
@[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 | mem_divisorsAntidiagonalList | null |
swap_mem_divisorsAntidiagonalList {a : ℕ × ℕ} :
a.swap ∈ n.divisorsAntidiagonalList ↔ a ∈ n.divisorsAntidiagonalList := 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_divisorsAntidiagonalList | null |
reverse_divisorsAntidiagonalList (n : ℕ) :
n.divisorsAntidiagonalList.reverse = n.divisorsAntidiagonalList.map .swap := by
have : IsAsymm (ℕ × ℕ) (·.snd < ·.snd) := ⟨fun _ _ ↦ lt_asymm⟩
refine List.eq_of_perm_of_sorted ?_ sorted_divisorsAntidiagonalList_snd.reverse <|
sorted_divisorsAntidiagonalList_fst.map... | 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 | reverse_divisorsAntidiagonalList | null |
ne_zero_of_mem_divisorsAntidiagonal {p : ℕ × ℕ} (hp : p ∈ n.divisorsAntidiagonal) :
p.1 ≠ 0 ∧ p.2 ≠ 0 := by
obtain ⟨hp₁, hp₂⟩ := Nat.mem_divisorsAntidiagonal.mp hp
exact mul_ne_zero_iff.mp (hp₁.symm ▸ hp₂) | 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 | ne_zero_of_mem_divisorsAntidiagonal | null |
left_ne_zero_of_mem_divisorsAntidiagonal {p : ℕ × ℕ} (hp : p ∈ n.divisorsAntidiagonal) :
p.1 ≠ 0 :=
(ne_zero_of_mem_divisorsAntidiagonal hp).1 | 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 | left_ne_zero_of_mem_divisorsAntidiagonal | null |
right_ne_zero_of_mem_divisorsAntidiagonal {p : ℕ × ℕ} (hp : p ∈ n.divisorsAntidiagonal) :
p.2 ≠ 0 :=
(ne_zero_of_mem_divisorsAntidiagonal hp).2 | 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 | right_ne_zero_of_mem_divisorsAntidiagonal | null |
divisor_le {m : ℕ} : n ∈ divisors m → n ≤ m := by
rcases m with - | m
· simp
· simp only [mem_divisors, Nat.succ_ne_zero m, and_true, Ne, not_false_iff]
exact Nat.le_of_dvd (Nat.succ_pos m)
@[gcongr] | 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 | divisor_le | null |
divisors_subset_of_dvd {m : ℕ} (hzero : n ≠ 0) (h : m ∣ n) : divisors m ⊆ divisors n :=
Finset.subset_iff.2 fun _x hx => Nat.mem_divisors.mpr ⟨(Nat.mem_divisors.mp hx).1.trans h, hzero⟩ | 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_subset_of_dvd | null |
card_divisors_le_self (n : ℕ) : #n.divisors ≤ n := calc
_ ≤ #(Ico 1 (n + 1)) := by
apply card_le_card
simp only [divisors, filter_subset]
_ = n := by rw [card_Ico, add_tsub_cancel_right] | 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 | card_divisors_le_self | null |
divisors_subset_properDivisors {m : ℕ} (hzero : n ≠ 0) (h : m ∣ n) (hdiff : m ≠ n) :
divisors m ⊆ properDivisors n := by
apply Finset.subset_iff.2
intro x hx
exact
Nat.mem_properDivisors.2
⟨(Nat.mem_divisors.1 hx).1.trans h,
lt_of_le_of_lt (divisor_le hx)
(lt_of_le_of_ne (divisor_l... | 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_subset_properDivisors | null |
divisors_filter_dvd_of_dvd {n m : ℕ} (hn : n ≠ 0) (hm : m ∣ n) :
{d ∈ n.divisors | d ∣ m} = m.divisors := by
ext k
simp_rw [mem_filter, mem_divisors]
exact ⟨fun ⟨_, hkm⟩ ↦ ⟨hkm, ne_zero_of_dvd_ne_zero hn hm⟩, fun ⟨hk, _⟩ ↦ ⟨⟨hk.trans hm, hn⟩, hk⟩⟩
@[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 | divisors_filter_dvd_of_dvd | null |
divisors_zero : divisors 0 = ∅ := by
ext
simp
@[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_zero | null |
properDivisors_zero : properDivisors 0 = ∅ := by
ext
simp
@[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 | properDivisors_zero | null |
nonempty_divisors : (divisors n).Nonempty ↔ n ≠ 0 :=
⟨fun ⟨m, hm⟩ hn ↦ by simp [hn] at hm, fun hn ↦ ⟨1, one_mem_divisors.2 hn⟩⟩
@[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 | nonempty_divisors | null |
divisors_eq_empty : divisors n = ∅ ↔ n = 0 :=
not_nonempty_iff_eq_empty.symm.trans nonempty_divisors.not_left | 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 | divisors_eq_empty | null |
properDivisors_subset_divisors : properDivisors n ⊆ divisors n :=
filter_subset_filter _ <| Ico_subset_Ico_right n.le_succ
@[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 | properDivisors_subset_divisors | null |
divisors_one : divisors 1 = {1} := by
ext
simp
@[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_one | null |
properDivisors_one : properDivisors 1 = ∅ := by rw [properDivisors, Ico_self, filter_empty] | 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_one | null |
pos_of_mem_divisors {m : ℕ} (h : m ∈ n.divisors) : 0 < m := by
cases m
· rw [mem_divisors, zero_dvd_iff (a := n)] at h
cases h.2 h.1
apply Nat.succ_pos | 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 | pos_of_mem_divisors | null |
pos_of_mem_properDivisors {m : ℕ} (h : m ∈ n.properDivisors) : 0 < m :=
pos_of_mem_divisors (properDivisors_subset_divisors 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 | pos_of_mem_properDivisors | null |
one_mem_properDivisors_iff_one_lt : 1 ∈ n.properDivisors ↔ 1 < n := by
rw [mem_properDivisors, and_iff_right (one_dvd _)]
@[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 | one_mem_properDivisors_iff_one_lt | null |
sup_divisors_id (n : ℕ) : n.divisors.sup id = n := by
refine le_antisymm (Finset.sup_le fun _ ↦ divisor_le) ?_
rcases Decidable.eq_or_ne n 0 with rfl | hn
· apply zero_le
· exact Finset.le_sup (f := id) <| mem_divisors_self n hn | 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 | sup_divisors_id | null |
one_lt_of_mem_properDivisors {m n : ℕ} (h : m ∈ n.properDivisors) : 1 < n :=
lt_of_le_of_lt (pos_of_mem_properDivisors h) (mem_properDivisors.1 h).2 | 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 | one_lt_of_mem_properDivisors | null |
one_lt_div_of_mem_properDivisors {m n : ℕ} (h : m ∈ n.properDivisors) :
1 < n / m := by
obtain ⟨h_dvd, h_lt⟩ := mem_properDivisors.mp h
rwa [Nat.lt_div_iff_mul_lt' h_dvd, mul_one] | 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 | one_lt_div_of_mem_properDivisors | null |
mem_properDivisors_iff_exists {m n : ℕ} (hn : n ≠ 0) :
m ∈ n.properDivisors ↔ ∃ k > 1, n = m * k := by
refine ⟨fun h ↦ ⟨n / m, one_lt_div_of_mem_properDivisors h, ?_⟩, ?_⟩
· exact (Nat.mul_div_cancel' (mem_properDivisors.mp h).1).symm
· rintro ⟨k, hk, rfl⟩
rw [mul_ne_zero_iff] at hn
exact mem_properDi... | 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_properDivisors_iff_exists | See also `Nat.mem_properDivisors`. |
nonempty_properDivisors : n.properDivisors.Nonempty ↔ 1 < n :=
⟨fun ⟨_m, hm⟩ ↦ one_lt_of_mem_properDivisors hm, fun hn ↦
⟨1, one_mem_properDivisors_iff_one_lt.2 hn⟩⟩
@[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 | nonempty_properDivisors | null |
properDivisors_eq_empty : n.properDivisors = ∅ ↔ n ≤ 1 := by
rw [← not_nonempty_iff_eq_empty, nonempty_properDivisors, not_lt]
@[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 | properDivisors_eq_empty | null |
divisorsAntidiagonal_zero : divisorsAntidiagonal 0 = ∅ := by
ext
simp
@[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_zero | null |
divisorsAntidiagonal_one : divisorsAntidiagonal 1 = {(1, 1)} := by
ext
simp [mul_eq_one, Prod.ext_iff]
@[simp high] | 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 |
swap_mem_divisorsAntidiagonal {x : ℕ × ℕ} :
x.swap ∈ divisorsAntidiagonal n ↔ x ∈ divisorsAntidiagonal n := by
rw [mem_divisorsAntidiagonal, mem_divisorsAntidiagonal, mul_comm, Prod.swap] | 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 | swap_mem_divisorsAntidiagonal | null |
prodMk_mem_divisorsAntidiag {x y : ℕ} (hn : n ≠ 0) :
(x, y) ∈ n.divisorsAntidiagonal ↔ x * y = n := by simp [hn] | 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 |
fst_mem_divisors_of_mem_antidiagonal {x : ℕ × ℕ} (h : x ∈ divisorsAntidiagonal n) :
x.fst ∈ divisors n := by
rw [mem_divisorsAntidiagonal] at h
simp [Dvd.intro _ h.1, h.2] | 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 | fst_mem_divisors_of_mem_antidiagonal | null |
snd_mem_divisors_of_mem_antidiagonal {x : ℕ × ℕ} (h : x ∈ divisorsAntidiagonal n) :
x.snd ∈ divisors n := by
rw [mem_divisorsAntidiagonal] at h
simp [Dvd.intro_left _ h.1, h.2]
@[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 | snd_mem_divisors_of_mem_antidiagonal | null |
map_swap_divisorsAntidiagonal :
(divisorsAntidiagonal n).map (Equiv.prodComm _ _).toEmbedding = divisorsAntidiagonal n := by
rw [← coe_inj, coe_map, Equiv.coe_toEmbedding, Equiv.coe_prodComm,
Set.image_swap_eq_preimage_swap]
ext
exact swap_mem_divisorsAntidiagonal
@[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_swap_divisorsAntidiagonal | null |
image_fst_divisorsAntidiagonal : (divisorsAntidiagonal n).image Prod.fst = divisors n := by
ext
simp [Dvd.dvd, @eq_comm _ n (_ * _)]
@[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 | image_fst_divisorsAntidiagonal | null |
image_snd_divisorsAntidiagonal : (divisorsAntidiagonal n).image Prod.snd = divisors n := by
rw [← map_swap_divisorsAntidiagonal, map_eq_image, image_image]
exact image_fst_divisorsAntidiagonal | 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_snd_divisorsAntidiagonal | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.