statement stringlengths 2 2.94k | proof stringlengths 0 6.15k | type stringclasses 9
values | symbolic_name stringlengths 4 131 | library stringclasses 71
values | filename stringclasses 155
values | imports listlengths 0 12 | deps listlengths 0 11 | docstring stringlengths 0 1.4k | source_url stringclasses 1
value | commit stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|
ker_RtoT_le_nilradical : RingHom.ker RtoT ≤ nilradical R₀ | by
have : Module.Finite Λ M₀ := by
cases isEmpty_or_nonempty ι
· cases F.neBot.1 (Subsingleton.elim _ _)
have i := Nonempty.some (inferInstance : Nonempty ι)
exact Module.Finite.equiv (sM i)
have : Module.Finite R₀ M₀ := .of_restrictScalars_finite Λ _ _
rw [nilradical, Ideal.radical_eq_sInf, le_sI... | theorem | ker_RtoT_le_nilradical | Patching | FLT/Patching/REqualsT.lean | [] | [
"support_eq_top"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
Submodule.map_algebraMap_smul {R S M : Type*} [CommRing R] [CommRing S] [AddCommGroup M]
[Module R M] [Module S M] [Algebra R S] [IsScalarTower R S M] (I : Ideal R)
(N : Submodule S M) :
I.map (algebraMap R S) • N = I • N | by
apply le_antisymm
· rw [Submodule.smul_le]
intro r hr n hn
induction hr using Submodule.span_induction with
| mem x h =>
obtain ⟨x, hx, rfl⟩ := h
rw [algebraMap_smul]
exact AddSubmonoid.smul_mem_smul hx hn
| zero => exact zero_smul S n ▸ zero_mem _
| add x y hx hy _ _ => rw ... | lemma | Submodule.map_algebraMap_smul | Patching | FLT/Patching/System.lean | [
"Mathlib.RingTheory.Length"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
maximalIdeal_pow_bound_le_smul_top [IsTopologicalRing Λ] (i) (α : OpenIdeals Λ) :
(maximalIdeal (R i) ^ (Nat.card (Λ ⧸ α.1) ^ bound Λ M) • ⊤ :
Submodule (R i) (M i)) ≤ α.1 • ⊤ | by
rw [← Submodule.map_algebraMap_smul α.1]
let α' := α.1.map (algebraMap Λ (R i))
have : Finite (Λ ⧸ α.1) := AddSubgroup.quotient_finite_of_isOpen _ α.2
have : Finite (M i ⧸ (α' • ⊤ : Submodule (R i) (M i))) := by
have := Module.UniformlyBoundedRank.finite_quotient_smul Λ M i α.1
refine (QuotientAddGro... | lemma | maximalIdeal_pow_bound_le_smul_top | Patching | FLT/Patching/System.lean | [
"Mathlib.RingTheory.Length"
] | [
"IsLocalRing.maximalIdeal_pow_card_smul_top_le",
"Module.UniformlyBoundedRank.card_quotient_le",
"Module.UniformlyBoundedRank.finite_quotient_smul",
"OpenIdeals",
"Submodule.map_algebraMap_smul"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
PatchingAlgebra.smulData where
/-- For each open ideal `α` of `Λ`, the exponent `f α` such that
`m(R i)^(f α) • M i ⊆ α • M i` for every `i`. -/
f : OpenIdeals Λ → ℕ
pow_f_smul_le : ∀ i α, (maximalIdeal (R i) ^ (f α) • ⊤ : Submodule (R i) (M i)) ≤ α.1 • ⊤
f_mono : Antitone f | class | PatchingAlgebra.smulData | Patching | FLT/Patching/System.lean | [
"Mathlib.RingTheory.Length"
] | [
"OpenIdeals"
] | Compatibility data between the local rings `R i` and modules `M i` and the open
ideals of `Λ`: consists of an antitone function `f : OpenIdeals Λ → ℕ` such that
`m(R i)^(f α) • M i ⊆ α • M i` for all `i`. | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
IsPatchingSystem.isModuleQuotient [PatchingAlgebra.smulData Λ R M] (α : OpenIdeals Λ) (i) :
Module (R i ⧸ (maximalIdeal (R i) ^ (PatchingAlgebra.smulData.f R M α)))
(M i ⧸ (α.1 • ⊤ : Submodule (R i) (M i))) | Module.IsTorsionBySet.module <| by
rw [Module.isTorsionBySet_quotient_iff]
intro r x hx
exact PatchingAlgebra.smulData.pow_f_smul_le _ _ (Submodule.smul_mem_smul hx trivial) | instance | IsPatchingSystem.isModuleQuotient | Patching | FLT/Patching/System.lean | [
"Mathlib.RingTheory.Length"
] | [
"OpenIdeals",
"PatchingAlgebra.smulData"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
IsPatchingSystem.isModuleQuotient' [PatchingAlgebra.smulData Λ R M]
(α : OpenIdeals Λ) (i) :
Module (R i ⧸ (maximalIdeal (R i) ^ (PatchingAlgebra.smulData.f R M α)))
(M i ⧸ (α.1 • ⊤ : Submodule Λ (M i))) | IsPatchingSystem.isModuleQuotient .. | instance | IsPatchingSystem.isModuleQuotient' | Patching | FLT/Patching/System.lean | [
"Mathlib.RingTheory.Length"
] | [
"IsPatchingSystem.isModuleQuotient",
"OpenIdeals",
"PatchingAlgebra.smulData"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
PatchingAlgebra.faithfulSMul
(H₀ : ringKrullDim Rₒₒ < ⊤)
(H : .some (Module.depth Λ Λ) = ringKrullDim Rₒₒ) :
FaithfulSMul (PatchingAlgebra R F) (PatchingModule Λ M F) | by
let f := PatchingAlgebra.lift R F (fun i ↦ (fRₒₒ i).toRingHom)
have hf : Function.Surjective f :=
lift_surjective R F _ hfRₒₒ' hfRₒₒ
have hf' (r) : f (algebraMap Λ _ r) = algebraMap Λ _ r := by
refine Subtype.ext (funext fun k ↦ UltraProduct.π_eq_iff.mpr (.of_forall fun i ↦ ?_))
simp
letI := f.to... | lemma | PatchingAlgebra.faithfulSMul | Patching | FLT/Patching/System.lean | [
"Mathlib.RingTheory.Length"
] | [
"Module.UniformlyBoundedRank.rank_spec",
"Module.depth",
"Module.depth_le_dim",
"Module.depth_le_of_free",
"Module.depth_of_isScalarTower",
"Module.faithfulSMul_of_depth_eq_ringKrullDim",
"PatchingAlgebra",
"PatchingAlgebra.lift",
"PatchingModule",
"PatchingModule.rank_patchingModule"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
Ultrafilter.eventually_eventually_eq_of_finite
{α β : Type*} [Finite β] (F : Ultrafilter α) (f : α → β) :
∀ᶠ (i) (j) in F, f i = f j | by
obtain ⟨a, ha⟩ : ∃ a, ∀ᶠ i in F, f i = a := Ultrafilter.eventually_exists_iff.mp (by simp)
filter_upwards [ha] with i hi
filter_upwards [ha] with j hj
rw [hi, hj] | lemma | Ultrafilter.eventually_eventually_eq_of_finite | Patching | FLT/Patching/System.lean | [
"Mathlib.RingTheory.Length"
] | [
"Algebra.UniformlyBoundedRank",
"IsPatchingSystem"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
smul_lemma₀
(HCompat : ∀ i m (r : R i), sM i (Submodule.Quotient.mk (r • m)) =
sR i (Ideal.Quotient.mk _ r) • sM i (Submodule.Quotient.mk m))
(x : PatchingModule Λ M F)
(m : PatchingAlgebra R F)
[∀ (i : ι), IsLocalHom (Ideal.Quotient.mk (𝔫.map (algebraMap Λ (R i))))] :
PatchingModule.map Λ F ... | by
refine Subtype.ext (funext fun α ↦ ?_)
obtain ⟨x, hx⟩ := x
obtain ⟨m, hm⟩ := m
obtain ⟨x, rfl⟩ := PatchingModule.ofPi_surjective x
obtain ⟨m, rfl⟩ := PatchingAlgebra.ofPi_surjective m
replace hm (i j h) := hm i j h
simp only [PatchingAlgebra.ofPi_apply, UltraProduct.mapRingHom_π, Ideal.quotientMap_mk,
... | lemma | smul_lemma₀ | Patching | FLT/Patching/System.lean | [
"Mathlib.RingTheory.Length"
] | [
"PatchingAlgebra",
"PatchingAlgebra.map",
"PatchingAlgebra.ofPi_apply",
"PatchingAlgebra.ofPi_surjective",
"PatchingModule",
"PatchingModule.map",
"PatchingModule.ofPi_surjective",
"Submodule.map_algebraMap_smul",
"UltraProduct.mapRingHom_π",
"UltraProduct.π_eq_iff",
"UltraProduct.πₗ"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
smul_lemma₁
(x : M₀)
(m : R₀) :
(PatchingModule.constEquiv Λ F M₀) (m • x) =
(PatchingAlgebra.constEquiv F R₀) m • (PatchingModule.constEquiv Λ F M₀) x | rfl | lemma | smul_lemma₁ | Patching | FLT/Patching/System.lean | [
"Mathlib.RingTheory.Length"
] | [
"Algebra.UniformlyBoundedRank",
"IsPatchingSystem",
"PatchingAlgebra.constEquiv",
"PatchingModule.constEquiv"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
smul_lemma
(HCompat : ∀ i m (r : R i), sM i (Submodule.Quotient.mk (r • m)) =
sR i (Ideal.Quotient.mk _ r) • sM i (Submodule.Quotient.mk m))
(m : PatchingAlgebra R F)
(x : PatchingModule Λ M F ⧸ (𝔫 • ⊤ : Submodule (PatchingAlgebra R F)
(PatchingModule Λ M F))) :
PatchingModule.quotientE... | by
obtain ⟨x, rfl⟩ := Submodule.Quotient.mk_surjective _ x
apply (PatchingModule.constEquiv Λ F M₀).injective
refine ((PatchingModule.constEquiv Λ F M₀).apply_symm_apply _).trans ?_
have (i : ι) : Nontrivial (R i ⧸ Ideal.map (algebraMap Λ (R i)) 𝔫) :=
(sR i).toRingHom.domain_nontrivial
have (i : ι) : IsL... | lemma | smul_lemma | Patching | FLT/Patching/System.lean | [
"Mathlib.RingTheory.Length"
] | [
"PatchingAlgebra",
"PatchingAlgebra.constEquiv",
"PatchingAlgebra.ofPi_surjective",
"PatchingAlgebra.quotientToOver",
"PatchingModule",
"PatchingModule.constEquiv",
"PatchingModule.ofPi_surjective",
"PatchingModule.quotientEquivOver",
"smul_lemma₀",
"smul_lemma₁"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
support_eq_top
(HCompat : ∀ i m (r : R i), sM i (Submodule.Quotient.mk (r • m)) =
sR i (Ideal.Quotient.mk _ r) • sM i (Submodule.Quotient.mk m))
(H₀ : ringKrullDim Rₒₒ < ⊤)
(H : .some (Module.depth Λ Λ) = ringKrullDim Rₒₒ) : Module.support R₀ M₀ = Set.univ | by
have : Module.Finite Λ M₀ := by
cases isEmpty_or_nonempty ι
· cases F.neBot.1 (Subsingleton.elim _ _)
have i := Nonempty.some (inferInstance: Nonempty ι)
exact Module.Finite.equiv (sM i)
have : Module.Finite R₀ M₀ := .of_restrictScalars_finite Λ _ _
have := PatchingAlgebra.faithfulSMul Λ R M F ... | lemma | support_eq_top | Patching | FLT/Patching/System.lean | [
"Mathlib.RingTheory.Length"
] | [
"Module.depth",
"PatchingAlgebra",
"PatchingAlgebra.faithfulSMul",
"PatchingAlgebra.quotientToOver",
"PatchingAlgebra.surjective_quotientToOver",
"PatchingModule",
"PatchingModule.quotientEquivOver",
"Submodule.map_algebraMap_smul",
"smul_lemma"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
eventuallyProd (F : Filter ι) : Submodule (Π i, R i) (Π i, M i) | where
carrier := { v | ∀ᶠ i in F, v i ∈ N i }
add_mem' hv hw := by filter_upwards [hv, hw]; simp_all [add_mem]
zero_mem' := by simp [zero_mem]
smul_mem' r v hv := by filter_upwards [hv]; simp_all [Submodule.smul_mem] | def | eventuallyProd | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [] | Given a filter `F` on the index set and a family of submodules `N i ≤ M i`, the submodule
of `Π i, M i` consisting of those tuples `v` for which `v i ∈ N i` holds `F`-eventually. | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 |
mem_eventuallyProd {F : Filter ι} {x} :
x ∈ eventuallyProd N F ↔ ∀ᶠ i in F, x i ∈ N i | Iff.rfl | lemma | mem_eventuallyProd | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"eventuallyProd"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
eventuallyProd_mono_left
{N₁ N₂ : Π i, Submodule (R i) (M i)} (h : N₁ ≤ N₂) :
eventuallyProd N₁ F ≤ eventuallyProd N₂ F | by
simp_rw [Pi.le_def, SetLike.le_def] at h
exact fun x hx ↦ Eventually.mp hx (by aesop) | lemma | eventuallyProd_mono_left | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"eventuallyProd"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
eventuallyProd_mono_right {F G : Filter ι} (e : F ≤ G) :
eventuallyProd N G ≤ eventuallyProd N F | fun _ ↦ Eventually.filter_mono e | lemma | eventuallyProd_mono_right | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"eventuallyProd"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
eventuallyProd_eq_sup :
eventuallyProd N F = eventuallyProd ⊥ F ⊔ Submodule.pi' N | by
classical
refine le_antisymm ?_ (sup_le ?_ ?_)
· intro x hx
simp only [mem_eventuallyProd] at hx
suffices ∃ y : Π i, M i, (∀ᶠ i in F, y i = 0) ∧ ∀ i, x i - y i ∈ N i by
simpa [Submodule.mem_sup, @and_comm _ (_ = _), ← eq_sub_iff_add_eq']
refine ⟨(fun i ↦ if x i ∈ N i then 0 else x i), ?_, fun... | lemma | eventuallyProd_eq_sup | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"Submodule.pi'",
"eventuallyProd",
"mem_eventuallyProd"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
eventuallyProd.isPrime (F : Ultrafilter ι) [H : ∀ i, (I i).IsPrime] :
Ideal.IsPrime (eventuallyProd I F) | where
ne_top' := by
rw [ne_eq, Ideal.eq_top_iff_one]
simp only [mem_eventuallyProd, Pi.one_apply, not_eventually]
simp only [← Ideal.eq_top_iff_one, (H _).ne_top, not_false_eq_true,
Ultrafilter.frequently_iff_eventually, eventually_true]
mem_or_mem' := by
intros v w
simp only [mem_eventual... | instance | eventuallyProd.isPrime | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"eventuallyProd",
"mem_eventuallyProd"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
UltraProduct : Type _ | (Π i, M i) ⧸ eventuallyProd (R := fun _ ↦ ℤ) (M := M) ⊥ F | def | UltraProduct | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"eventuallyProd"
] | The ultraproduct of a family of additive groups `M i` along
a filter `F`: the quotient of `Π i, M i` by tuples that are zero `F`-eventually. | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 |
UltraProduct.π : (Π i, R i) →+* UltraProduct R F | Ideal.Quotient.mk (eventuallyProd (R := R) (M := R) ⊥ F) | def | UltraProduct.π | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"UltraProduct",
"eventuallyProd"
] | The canonical projection from the product `Π i, R i` to the ultraproduct as a ring
homomorphism. | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 |
UltraProduct.πₗ : (Π i, M i) →ₗ[Π i, R i] UltraProduct M F | Submodule.mkQ (eventuallyProd (R := R) (M := M) ⊥ F) | def | UltraProduct.πₗ | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"UltraProduct",
"eventuallyProd"
] | The canonical projection from the product `Π i, M i` of `R i`-modules to the ultraproduct as a
`Π i, R i`-linear map. | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 |
UltraProduct.π_surjective : Function.Surjective (π R F) | Submodule.mkQ_surjective _ | lemma | UltraProduct.π_surjective | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
UltraProduct.πₗ_surjective : Function.Surjective (πₗ R M F) | Submodule.mkQ_surjective _ | lemma | UltraProduct.πₗ_surjective | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
UltraProduct.instIsScalarTower
{R₁ : Type*} [CommRing R₁] [∀ i, Module R₁ (M i)] [Algebra R₀ R₁]
[∀ i, IsScalarTower R₀ R₁ (M i)] :
IsScalarTower R₀ R₁ (UltraProduct M F) | inferInstanceAs (IsScalarTower R₀ R₁ ((Π i, M i) ⧸ eventuallyProd (R := fun _ ↦ R₁) (M := M) ⊥ F)) | lemma | UltraProduct.instIsScalarTower | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"UltraProduct",
"eventuallyProd"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
UltraProduct.πₗ_eq_zero {x} : πₗ R M F x = 0 ↔ ∀ᶠ i in F, x i = 0 | Submodule.Quotient.mk_eq_zero _ | lemma | UltraProduct.πₗ_eq_zero | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
UltraProduct.πₗ_eq_iff {x y} : πₗ R M F x = πₗ R M F y ↔ ∀ᶠ i in F, x i = y i | (Submodule.Quotient.eq _).trans (by simp [sub_eq_zero]) | lemma | UltraProduct.πₗ_eq_iff | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
UltraProduct.π_eq_iff {x y} : π R F x = π R F y ↔ ∀ᶠ i in F, x i = y i | (Submodule.Quotient.eq _).trans (by simp [sub_eq_zero]) | lemma | UltraProduct.π_eq_iff | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
UltraProduct.π_eq_zero_iff {x} : π R F x = 0 ↔ ∀ᶠ i in F, x i = 0 | UltraProduct.π_eq_iff | lemma | UltraProduct.π_eq_zero_iff | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"UltraProduct.π_eq_iff"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
UltraProduct.π_smul {r} {m : UltraProduct M F} : π R F r • m = r • m | rfl | lemma | UltraProduct.π_smul | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"UltraProduct"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
UltraProduct.map (f : ∀ i, M i →ₗ[R i] N i) :
UltraProduct M F →ₗ[∀ i, R i] UltraProduct N F | Submodule.mapQ (eventuallyProd (R := R) (M := M) ⊥ F)
(eventuallyProd (R := R) (M := N) ⊥ F) (LinearMap.piMap' f) fun v i ↦ by
filter_upwards [i] with i hi; simpa using congr(f i $hi) | def | UltraProduct.map | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"LinearMap.piMap'",
"UltraProduct",
"eventuallyProd"
] | A family of linear maps `f i : M i →ₗ[R i] N i` induces a linear map between the
corresponding ultraproducts. | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 |
UltraProduct.map_πₗ (f : ∀ i, M i →ₗ[R i] N i) (x) :
UltraProduct.map F f (πₗ R M F x) = πₗ R N F (fun i ↦ f i (x i)) | rfl | lemma | UltraProduct.map_πₗ | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"UltraProduct.map"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
UltraProduct.mapRingHom {S : ι → Type*} [∀ i, CommRing (S i)] (f : ∀ i, R i →+* S i) :
UltraProduct R F →+* UltraProduct S F | Ideal.quotientMap (I := eventuallyProd (R := R) (M := R) ⊥ F)
(eventuallyProd (R := S) (M := S) ⊥ F) (RingHom.pi fun i ↦ (f i).comp (Pi.evalRingHom _ i))
(fun i H ↦ H.mono fun a ha ↦ by simp [show i a = 0 from ha]) | def | UltraProduct.mapRingHom | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"UltraProduct",
"eventuallyProd"
] | A family of ring homomorphisms `f i : R i →+* S i` induces a ring homomorphism between
the corresponding ultraproducts. | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 |
UltraProduct.mapRingHom_π {S : ι → Type*} [∀ i, CommRing (S i)] (f : ∀ i, R i →+* S i) (x) :
mapRingHom F f (π R F x) = π S F (fun i ↦ f i (x i)) | rfl | lemma | UltraProduct.mapRingHom_π | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
UltraProduct.map_surjective (f : ∀ i, M i →ₗ[R i] N i)
(hf : ∀ i, Function.Surjective (f i)) :
Function.Surjective (map F f) | by
intro x
obtain ⟨x, rfl⟩ := πₗ_surjective R x
choose y hy using fun i ↦ (hf _ (x i))
exact ⟨πₗ R M F y, by simp [hy]⟩ | lemma | UltraProduct.map_surjective | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
UltraProduct.mapRingHom_surjective
{S : ι → Type*} [∀ i, CommRing (S i)] (f : ∀ i, R i →+* S i)
(hf : ∀ i, Function.Surjective (f i)) :
Function.Surjective (mapRingHom F f) | UltraProduct.map_surjective F (fun i ↦ (f i).toAddMonoidHom.toIntLinearMap) hf | lemma | UltraProduct.mapRingHom_surjective | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"UltraProduct.map_surjective"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
UltraProduct.surjective_of_eventually_surjective
[Finite M₀] (F : Ultrafilter ι) (hf : ∀ᶠ i in F, Function.Surjective (f i)) :
Function.Surjective ((πₗ (fun _ ↦ R₀) M F).restrictScalars R₀ ∘ₗ LinearMap.pi f) | by
intro x
obtain ⟨x, rfl⟩ := πₗ_surjective (fun _ ↦ R₀) x
have : ∀ᶠ i in F, ∃ a, f i a = x i := by filter_upwards [hf] with i hi; exact hi _
obtain ⟨a, ha⟩ := Ultrafilter.eventually_exists_iff.mp this
exact ⟨a, UltraProduct.πₗ_eq_iff.mpr ha⟩ | lemma | UltraProduct.surjective_of_eventually_surjective | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
UltraProduct.bijective_of_eventually_bijective
[Finite M₀] (F : Ultrafilter ι) (hf : ∀ᶠ i in F, Function.Bijective (f i)) :
Function.Bijective ((πₗ (fun _ ↦ R₀) M F).restrictScalars R₀ ∘ₗ LinearMap.pi f) | by
constructor
· rw [injective_iff_map_eq_zero]
intro x hx
replace hx : ∀ᶠ i in F, f i x = 0 := by simpa using hx
obtain ⟨i, h₁, h₂⟩ := (hx.and hf).exists
exact h₂.1 (h₁.trans (f i).map_zero.symm)
· intro x
obtain ⟨x, rfl⟩ := πₗ_surjective (fun _ ↦ R₀) x
have : ∀ᶠ i in F, ∃ a, f i a = x i ... | lemma | UltraProduct.bijective_of_eventually_bijective | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
UltraProduct.isUnit_π_iff {x : Π i, R i} : IsUnit (π R F x) ↔ ∀ᶠ i in F, IsUnit (x i) | by
simp_rw [isUnit_iff_exists_inv, π_surjective.exists, ← map_one (π R F), ← map_mul,
UltraProduct.π_eq_iff]
exact .symm <| Filter.skolem (P := (x · * · = 1)) | lemma | UltraProduct.isUnit_π_iff | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"UltraProduct.π_eq_iff"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
UltraProduct.exists_bijective_of_bddAbove_card [Algebra.FiniteType ℤ R₀]
(F : Ultrafilter ι) (N : ℕ) (H : ∀ᶠ i in F, Finite (M i) ∧ Nat.card (M i) < N) :
∀ᶠ i in F,
(∀ᶠ j in F, Nonempty (M i ≃ₗ[R₀] M j)) ∧
Function.Bijective ((πₗ (fun _ ↦ R₀) M F).restrictScalars R₀ ∘ₗ LinearMap.pi fun j ↦
if ... | by
have : ∀ᶠ i in F, ∃ (α : ModuleTypeCardLT R₀ N), Nonempty (M i ≃ₗ[R₀] Fin α.1) := by
filter_upwards [H] with i ⟨h₁, h₂⟩
exact ⟨_, ⟨ModuleTypeCardLT.equivOfModule N h₂⟩⟩
obtain ⟨a, ha⟩ := Ultrafilter.eventually_exists_iff.mp this
filter_upwards [ha] with i ⟨ei⟩
have := ei.toEquiv.finite_iff.mpr inferI... | lemma | UltraProduct.exists_bijective_of_bddAbove_card | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"ModuleTypeCardLT"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
UltraProduct.exists_algEquiv_of_bddAbove_card
[TopologicalSpace R₀]
[IsTopologicalRing R₀]
[Algebra.TopologicallyFG ℤ R₀]
[∀ i, TopologicalSpace (R i)]
[∀ i, T2Space (R i)] (F : Ultrafilter ι)
(N : ℕ) (H : ∀ᶠ i in F, Finite (R i) ∧ Nat.card (R i) < N)
(hcont : ∀ᶠ i in F, ContinuousSMul R₀ (R... | by
classical
have : ∀ᶠ i in F, ∃ (α : TopologicalAlgebraTypeCardLT R₀ N)
(e : R i ≃ₐ[R₀] Fin α.1), IsHomeomorph e := by
filter_upwards [H, hcont] with i ⟨h₁, h₂⟩ h₃
exact ⟨_, TopologicalAlgebraTypeCardLT.equivOfAlgebra N _ h₂,
TopologicalAlgebraTypeCardLT.isHomeomorph_equivOfAlgebra N _ h₂⟩
obta... | lemma | UltraProduct.exists_algEquiv_of_bddAbove_card | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"Algebra.TopologicallyFG",
"TopologicalAlgebraTypeCardLT",
"TopologicalAlgebraTypeCardLT.equivOfAlgebra",
"TopologicalAlgebraTypeCardLT.isHomeomorph_equivOfAlgebra",
"UltraProduct",
"UltraProduct.bijective_of_eventually_bijective"
] | Let `R₀` be a topological ring, topologically of finite type (over `ℤ`).
Consider a family of (cardinality) finite continuous `R₀`-algebras `R i` with the discrete topology
whose cardinalites are unifomly bounded.
Then `𝒰(Rᵢ) ≃ₐ[R] R i` for `F`-many `i`. | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 |
UltraProduct.exists_ringEquiv_of_bddAbove_card
[TopologicalSpace R₀]
[IsTopologicalRing R₀]
[Algebra.TopologicallyFG ℤ R₀]
[∀ i, TopologicalSpace (R i)]
[∀ i, IsTopologicalRing (R i)]
[∀ i, T2Space (R i)] (F : Ultrafilter ι)
(N : ℕ) (H : ∀ᶠ i in F, Finite (R i) ∧ Nat.card (R i) < N)
(f :... | by
classical
letI := fun i ↦ (f i).toAlgebra
have := UltraProduct.exists_algEquiv_of_bddAbove_card (R₀ := R₀) F N H
(by filter_upwards [hf] with i hi;
exact ⟨show Continuous fun p : R₀ × R i ↦ f i p.1 * p.2 by continuity⟩)
filter_upwards [this] with i ⟨e⟩
exact ⟨e, e.toAlgHom.comp_algebraMap⟩ | lemma | UltraProduct.exists_ringEquiv_of_bddAbove_card | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"Algebra.TopologicallyFG",
"UltraProduct",
"UltraProduct.exists_algEquiv_of_bddAbove_card"
] | Let `R₀` be a topological ring, topologically of finite type (over `ℤ`).
Consider a family of (cardinality) finite rings `R i` with the discrete topology
whose cardinalites are unifomly bounded.
Given a family of continuous ring homs `f i : R →+* R i`, there exists `F`-many `i` such that
`𝒰(Rᵢ) ≃+* R i` and this map ... | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 |
UltraProduct.continuous_of_bddAbove_card
[TopologicalSpace R₀]
[IsTopologicalRing R₀]
[Algebra.TopologicallyFG ℤ R₀]
[∀ i, TopologicalSpace (R i)]
[∀ i, IsTopologicalRing (R i)]
[∀ i, T2Space (R i)] (F : Ultrafilter ι)
(N : ℕ) (H : ∀ᶠ i in F, Finite (R i) ∧ Nat.card (R i) < N)
(f : ∀ i, ... | by
suffices IsOpen (X := R₀) (RingHom.ker ((π R F).comp (RingHom.pi f))) by
apply continuous_of_continuousAt_zero
rw [ContinuousAt, map_zero, nhds_discrete (UltraProduct R F), pure_zero, tendsto_zero]
exact this.mem_nhds (x := 0) (map_zero _)
obtain ⟨i, ⟨e, he⟩, hf, hR, H⟩ :=
((UltraProduct.exists_r... | lemma | UltraProduct.continuous_of_bddAbove_card | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"Algebra.TopologicallyFG",
"UltraProduct",
"UltraProduct.exists_ringEquiv_of_bddAbove_card"
] | Let `R₀` be a topological ring, topologically of finite type (over `ℤ`).
Consider a family of (cardinality) finite rings `R i` with the discrete topology
whose cardinalites are unifomly bounded.
Given a family of continuous ring homs `f i : R →+* R i`, the lift `R →+* 𝒰(Rᵢ)` is also continuous. | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 |
UltraProduct.surjective_of_bddAbove_card
[TopologicalSpace R₀]
[IsTopologicalRing R₀]
[Algebra.TopologicallyFG ℤ R₀]
[∀ i, TopologicalSpace (R i)]
[∀ i, IsTopologicalRing (R i)]
[∀ i, T2Space (R i)] (F : Ultrafilter ι)
(N : ℕ) (H : ∀ᶠ i in F, Finite (R i) ∧ Nat.card (R i) < N)
(f : ∀ i, ... | by
obtain ⟨i, ⟨e, he⟩, hf⟩ :=
((UltraProduct.exists_ringEquiv_of_bddAbove_card F N H f hf).and hf').exists
have : e.symm.toRingHom.comp (f i) = (π R F).comp (RingHom.pi f) := by
rw [← he, ← RingHom.comp_assoc]; simp
rw [← this]
exact e.symm.surjective.comp hf | lemma | UltraProduct.surjective_of_bddAbove_card | Patching | FLT/Patching/Ultraproduct.lean | [
"FLT.Patching.Utils.StructureFiniteness",
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"Algebra.TopologicallyFG",
"UltraProduct.exists_ringEquiv_of_bddAbove_card"
] | Let `R₀` be a topological ring, topologically of finite type (over `ℤ`).
Consider a family of (cardinality) finite rings `R i` with the discrete topology
whose cardinalites are unifomly bounded.
Given a family of continuous surjective ring homs `f i : R →+* R i`,
the lift `R →+* 𝒰(Rᵢ)` is also surjective. | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 |
vanishingFilter (p : Ideal (Π i, R i)) : Filter ι | where
sets := { s | (if · ∈ s then 0 else 1) ∈ p }
univ_sets := by simpa [-zero_mem] using! zero_mem p
sets_of_superset {s t} hs hst := by
change _ ∈ p
convert p.smul_mem (fun i ↦ if i ∈ t then 0 else 1) hs with i
simp [← ite_or, or_iff_right_of_imp (@hst _)]
inter_sets {s t} hs ht := by
change ... | def | vanishingFilter | Patching | FLT/Patching/VanishingFilter.lean | [
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [] | The vanishing filter of an ideal `p` of the product ring `Πᵢ Rᵢ` over an index
set `ι`: a set `s ⊆ ι` is in the vanishing filter if the element of `Πᵢ Rᵢ` which
is `0` on `s` and `1` outside `s` lies in `p`. | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 |
mem_vanishingFilter {p : Ideal (Π i, R i)} {s} :
s ∈ vanishingFilter p ↔ (if · ∈ s then 0 else 1) ∈ p | Iff.rfl | lemma | mem_vanishingFilter | Patching | FLT/Patching/VanishingFilter.lean | [
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"vanishingFilter"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
vanishingUltrafilter (p : Ideal (Π i, R i)) [p.IsPrime] : Ultrafilter ι | .ofComplNotMemIff (vanishingFilter p) <| by
classical
intro s
simp only [vanishingFilter, Filter.mem_mk, Set.mem_setOf_eq, Set.mem_compl_iff]
constructor
· intro H
refine (Ideal.IsPrime.mem_or_mem_of_mul_eq_zero ‹p.IsPrime› ?_).resolve_left H
ext i
simp only [ite_not, Pi.mul_apply,... | def | vanishingUltrafilter | Patching | FLT/Patching/VanishingFilter.lean | [
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"vanishingFilter"
] | The vanishing ultrafilter of a prime ideal `p` of the product ring.
See `vanishingFilter` for definition of a vanishing filter of an ideal of `Πᵢ Rᵢ`;
if `p` is prime then this is an ultrafilter. | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 |
mem_vanishingUltrafilter {p : Ideal (Π i, R i)} [p.IsPrime] {s} :
s ∈ vanishingUltrafilter p ↔ (fun i ↦ if i ∈ s then 0 else 1) ∈ p | Iff.rfl | lemma | mem_vanishingUltrafilter | Patching | FLT/Patching/VanishingFilter.lean | [
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"vanishingUltrafilter"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
eventually_vanishingFilter_not_isUnit
(p : Ideal (Π i, R i)) {x} (hx : x ∈ p) :
∀ᶠ i in vanishingFilter p, ¬ IsUnit (x i) | by
classical
have : (fun i ↦ if IsUnit (x i) then 1 else 0) ∈ p := by
convert p.mul_mem_left (fun i ↦ if h : IsUnit (x i) then (h.unit⁻¹ : _) else 0) hx with i
aesop
simp only [Filter.Eventually, mem_vanishingFilter, Set.mem_setOf_eq, Classical.ite_not]
convert this | lemma | eventually_vanishingFilter_not_isUnit | Patching | FLT/Patching/VanishingFilter.lean | [
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"mem_vanishingFilter",
"vanishingFilter"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
vanishingFilter_le {p : Ideal (Π i, R i)} {F : Filter ι} :
vanishingFilter p ≤ F ↔ eventuallyProd ⊥ F ≤ p | by
constructor
· rintro H v hv
convert Ideal.mul_mem_left _ v (H hv)
aesop
· intro H s hs
apply H
filter_upwards [hs]
aesop | lemma | vanishingFilter_le | Patching | FLT/Patching/VanishingFilter.lean | [
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"eventuallyProd",
"vanishingFilter"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
vanishingFilter_eventuallyProd (F : Filter ι) (hI : ∀ i, I i ≠ ⊤) :
vanishingFilter (eventuallyProd I F) = F | by
ext; simp[apply_ite, ← Ideal.eq_top_iff_one, hI] | lemma | vanishingFilter_eventuallyProd | Patching | FLT/Patching/VanishingFilter.lean | [
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"eventuallyProd",
"vanishingFilter"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
vanishingFilter_gc :
GaloisConnection (vanishingFilter ∘ ofDual)
(toDual ∘ eventuallyProd (⊥ : ∀ i, Ideal (R i))) | fun _ _ ↦ vanishingFilter_le | lemma | vanishingFilter_gc | Patching | FLT/Patching/VanishingFilter.lean | [
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"eventuallyProd",
"vanishingFilter",
"vanishingFilter_le"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
vanishingFilterGI [∀ i, Nontrivial (R i)] :
GaloisInsertion (vanishingFilter ∘ ofDual)
(toDual ∘ eventuallyProd (⊥ : ∀ i, Ideal (R i))) | where
gc := vanishingFilter_gc
le_l_u x := (by simp [vanishingFilter_eventuallyProd])
choice := _
choice_eq _ _ := rfl | def | vanishingFilterGI | Patching | FLT/Patching/VanishingFilter.lean | [
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"eventuallyProd",
"vanishingFilter",
"vanishingFilter_eventuallyProd",
"vanishingFilter_gc"
] | The Galois insertion between filters on `ι` and ideals of `Π i, R i` (for nontrivial `R i`)
formed by `vanishingFilter` and `eventuallyProd ⊥`. | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 |
vanishingFilter_antimono {p q : Ideal (Π i, R i)} (h : p ≤ q) :
vanishingFilter q ≤ vanishingFilter p | vanishingFilter_gc.monotone_l h | lemma | vanishingFilter_antimono | Patching | FLT/Patching/VanishingFilter.lean | [
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"vanishingFilter"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
eventuallyProd_vanishingFilter_le (p : Ideal (Π i, R i)) :
eventuallyProd ⊥ (vanishingFilter p) ≤ p | vanishingFilter_gc.le_u_l _ | lemma | eventuallyProd_vanishingFilter_le | Patching | FLT/Patching/VanishingFilter.lean | [
"Mathlib.Tactic.ContinuousFunctionalCalculus"
] | [
"eventuallyProd",
"vanishingFilter"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
IsAdicTopology (R) [CommRing R] [IsLocalRing R]
[TopologicalSpace R] [IsTopologicalRing R] : Prop where
isAdic : IsAdic (maximalIdeal R) | class | IsLocalRing.IsAdicTopology | Patching.Utils | FLT/Patching/Utils/AdicTopology.lean | [
"FLT.Patching.Utils.InverseLimit",
"FLT.Patching.Utils.Lemmas",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.Ring.Compact",
"Mathlib.Topology.Connected.Separation"
] | [] | `IsAdicTopology R` says that the topology on the local topological ring `R`
is the maximal ideal-adic one, that is, that a basis of neighbourhoods of `0` in `R`
is given by powers of the maximal ideal of `R`. | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
isOpen_maximalIdeal_pow'' (n : ℕ) : IsOpen (X := R) ↑(maximalIdeal R ^ n) | (isAdic_iff.mp IsLocalRing.IsAdicTopology.isAdic).1 _ | lemma | IsLocalRing.isOpen_maximalIdeal_pow'' | Patching.Utils | FLT/Patching/Utils/AdicTopology.lean | [
"FLT.Patching.Utils.InverseLimit",
"FLT.Patching.Utils.Lemmas",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.Ring.Compact",
"Mathlib.Topology.Connected.Separation"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
isOpen_maximalIdeal' : IsOpen (X := R) (maximalIdeal R) | pow_one (maximalIdeal R) ▸ isOpen_maximalIdeal_pow'' R 1 | lemma | IsLocalRing.isOpen_maximalIdeal' | Patching.Utils | FLT/Patching/Utils/AdicTopology.lean | [
"FLT.Patching.Utils.InverseLimit",
"FLT.Patching.Utils.Lemmas",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.Ring.Compact",
"Mathlib.Topology.Connected.Separation"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
hasBasis_maximalIdeal_pow :
Filter.HasBasis (𝓝 (0 : R)) (fun _ ↦ True) fun n ↦ ↑(maximalIdeal R ^ n) | IsLocalRing.IsAdicTopology.isAdic (R := R) ▸ Ideal.hasBasis_nhds_zero_adic (maximalIdeal R) | lemma | IsLocalRing.hasBasis_maximalIdeal_pow | Patching.Utils | FLT/Patching/Utils/AdicTopology.lean | [
"FLT.Patching.Utils.InverseLimit",
"FLT.Patching.Utils.Lemmas",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.Ring.Compact",
"Mathlib.Topology.Connected.Separation"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
Submodule.isCompact_of_fg {R M : Type*} [CommRing R] [TopologicalSpace R] [AddCommGroup M]
[Module R M]
[TopologicalSpace M] [IsModuleTopology R M] [CompactSpace R] {N : Submodule R M} (hN : N.FG) :
IsCompact (X := M) N | by
have := IsModuleTopology.toContinuousAdd R M
obtain ⟨s, hs⟩ := hN
have : LinearMap.range (Fintype.linearCombination R (α := s) Subtype.val) = N := by
simp [hs]
rw [← this]
refine isCompact_range ?_
simp only [Fintype.linearCombination, Finset.univ_eq_attach, LinearMap.coe_mk,
AddHom.coe_mk]
con... | lemma | IsLocalRing.Submodule.isCompact_of_fg | Patching.Utils | FLT/Patching/Utils/AdicTopology.lean | [
"FLT.Patching.Utils.InverseLimit",
"FLT.Patching.Utils.Lemmas",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.Ring.Compact",
"Mathlib.Topology.Connected.Separation"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
Ideal.isCompact_of_fg {R : Type*} [CommRing R] [TopologicalSpace R] [IsTopologicalRing R]
[CompactSpace R] {I : Ideal R} (hI : I.FG) : IsCompact (X := R) I | Submodule.isCompact_of_fg hI | lemma | IsLocalRing.Ideal.isCompact_of_fg | Patching.Utils | FLT/Patching/Utils/AdicTopology.lean | [
"FLT.Patching.Utils.InverseLimit",
"FLT.Patching.Utils.Lemmas",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.Ring.Compact",
"Mathlib.Topology.Connected.Separation"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
IsModuleTopology.compactSpace
(R M : Type*) [CommRing R] [TopologicalSpace R] [AddCommGroup M]
[Module R M] [TopologicalSpace M] [IsModuleTopology R M]
[CompactSpace R] [Module.Finite R M] : CompactSpace M | ⟨Submodule.isCompact_of_fg (Module.Finite.fg_top (R := R))⟩ | lemma | IsLocalRing.IsModuleTopology.compactSpace | Patching.Utils | FLT/Patching/Utils/AdicTopology.lean | [
"FLT.Patching.Utils.InverseLimit",
"FLT.Patching.Utils.Lemmas",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.Ring.Compact",
"Mathlib.Topology.Connected.Separation"
] | [
"IsModuleTopology.compactSpace"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
isCompact_of_isNoetherianRing [IsNoetherianRing R] [CompactSpace R] (I : Ideal R) :
IsCompact (X := R) I | Ideal.isCompact_of_fg (IsNoetherian.noetherian _) | lemma | IsLocalRing.isCompact_of_isNoetherianRing | Patching.Utils | FLT/Patching/Utils/AdicTopology.lean | [
"FLT.Patching.Utils.InverseLimit",
"FLT.Patching.Utils.Lemmas",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.Ring.Compact",
"Mathlib.Topology.Connected.Separation"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
isOpen_iff_finite_quotient' [CompactSpace R] {I : Ideal R} :
IsOpen (X := R) I ↔ Finite (R ⧸ I) | by
constructor
· intro H
exact AddSubgroup.quotient_finite_of_isOpen _ H
· intro H
obtain ⟨n, hn⟩ := exists_maximalIdeal_pow_le_of_isArtinianRing_quotient I
exact AddSubgroup.isOpen_mono (H₁ := (maximalIdeal R ^ n).toAddSubgroup)
(H₂ := I.toAddSubgroup) hn (isOpen_maximalIdeal_pow'' R n) | lemma | IsLocalRing.isOpen_iff_finite_quotient' | Patching.Utils | FLT/Patching/Utils/AdicTopology.lean | [
"FLT.Patching.Utils.InverseLimit",
"FLT.Patching.Utils.Lemmas",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.Ring.Compact",
"Mathlib.Topology.Connected.Separation"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
compactSpace_of_finite_residueField [IsNoetherianRing R] [Finite (ResidueField R)]
[IsAdicComplete (maximalIdeal R) R] :
CompactSpace R | by
let f : R →+* Π i : ℕ, R ⧸ (maximalIdeal R) ^ i := algebraMap _ _
have : Finite (R ⧸ maximalIdeal R) := ‹_›
have : ∀ i, Finite (R ⧸ (maximalIdeal R) ^ i) := fun i ↦
Ideal.finite_quotient_pow (IsNoetherian.noetherian _) _
have hf : Continuous f := by continuity
have : Topology.IsClosedEmbedding f := by
... | lemma | IsLocalRing.compactSpace_of_finite_residueField | Patching.Utils | FLT/Patching/Utils/AdicTopology.lean | [
"FLT.Patching.Utils.InverseLimit",
"FLT.Patching.Utils.Lemmas",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.Ring.Compact",
"Mathlib.Topology.Connected.Separation"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
Continuous.of_isLocalHom {R S : Type*} [CommRing R] [IsLocalRing R] [TopologicalSpace R]
[IsTopologicalRing R] [IsAdicTopology R] [CommRing S] [IsLocalRing S] [TopologicalSpace S]
[IsTopologicalRing S] [IsAdicTopology S] (f : R →+* S) [IsLocalHom f] : Continuous f | by
apply continuous_of_continuousAt_zero
unfold ContinuousAt
rw [map_zero]
apply ((hasBasis_maximalIdeal_pow R).tendsto_iff (hasBasis_maximalIdeal_pow S)).mpr ?_
simp only [SetLike.mem_coe, true_and, forall_const, ← SetLike.le_def, ← Ideal.mem_comap,
← Ideal.map_le_iff_le_comap, Ideal.map_pow]
intro n
... | lemma | IsLocalRing.Continuous.of_isLocalHom | Patching.Utils | FLT/Patching/Utils/AdicTopology.lean | [
"FLT.Patching.Utils.InverseLimit",
"FLT.Patching.Utils.Lemmas",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.Ring.Compact",
"Mathlib.Topology.Connected.Separation"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
withIdeal {R} [CommRing R] [IsLocalRing R] : WithIdeal R | ⟨maximalIdeal R⟩ | abbrev | IsLocalRing.withIdeal | Patching.Utils | FLT/Patching/Utils/AdicTopology.lean | [
"FLT.Patching.Utils.InverseLimit",
"FLT.Patching.Utils.Lemmas",
"Mathlib.Topology.Algebra.Algebra",
"Mathlib.Topology.Algebra.Ring.Compact",
"Mathlib.Topology.Connected.Separation"
] | [] | The default `WithIdeal` structure on a local ring `R`, picking out the maximal ideal. | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 |
Group.subsingleton_of_pow_prime_eq_one
(A : Type*) [CommGroup A] [TopologicalSpace A] [IsTopologicalGroup A]
[ConnectedSpace A] [CompactSpace A] [T2Space A]
(p : ℕ) (hp : p.Prime) (hAp : ∀ a : A, a ^ p = 1) :
Subsingleton A | by
sorry | theorem | Group.subsingleton_of_pow_prime_eq_one | Patching.Utils | FLT/Patching/Utils/CompactHausdorffRings.lean | [
"Mathlib.Data.Nat.Factorization.Induction",
"Mathlib.Topology.Algebra.Group.SubmonoidClosure",
"Mathlib.Topology.Algebra.Ring.Ideal"
] | [] | A connected compact Hausdorff vector space over `𝔽_p` is trivial. This might sound easy, but it
seems to require the fact that every nontrivial compact hausdorff group has a nontrivial continuous
character. This fact is a special case of Pontryagin duality, and also a consequence of the
Peter-Weyl theorem. This fact i... | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 |
Group.totallyDisconnected_of_pow_prime_eq_one
(A : Type*) [CommGroup A] [TopologicalSpace A] [IsTopologicalGroup A]
[T2Space A] [CompactSpace A] (p : ℕ) (hp : p.Prime) (hA : ∀ a : A, a ^ p = 1) :
TotallyDisconnectedSpace A | by
have : ConnectedSpace (Subgroup.connectedComponentOfOne A) :=
Subtype.connectedSpace isConnected_connectedComponent
have : CompactSpace (Subgroup.connectedComponentOfOne A) :=
isCompact_iff_compactSpace.mp (isClosed_connectedComponent.isCompact)
have := subsingleton_of_pow_prime_eq_one (Subgroup.connec... | theorem | Group.totallyDisconnected_of_pow_prime_eq_one | Patching.Utils | FLT/Patching/Utils/CompactHausdorffRings.lean | [
"Mathlib.Data.Nat.Factorization.Induction",
"Mathlib.Topology.Algebra.Group.SubmonoidClosure",
"Mathlib.Topology.Algebra.Ring.Ideal"
] | [] | A compact Hausdorff vector space over `𝔽_p` is totally disconnected. | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 |
Group.rootable
(A : Type*) [CommGroup A] [TopologicalSpace A] [IsTopologicalGroup A]
[ConnectedSpace A] [CompactSpace A] [T2Space A] : RootableBy A ℕ | by
apply rootableByOfPowLeftSurj
suffices ∀ p : ℕ, p.Prime → Function.Surjective fun a : A ↦ a ^ p by
apply Nat.prime_composite_induction
· simp
· simpa using! Function.surjective_id
· grind
· intro a _ ha b _ hb _
simp only [pow_mul]
exact (hb (by grind)).comp (ha (by grind))
intr... | def | Group.rootable | Patching.Utils | FLT/Patching/Utils/CompactHausdorffRings.lean | [
"Mathlib.Data.Nat.Factorization.Induction",
"Mathlib.Topology.Algebra.Group.SubmonoidClosure",
"Mathlib.Topology.Algebra.Ring.Ideal"
] | [] | A connected compact Hausdorff abelian topological group is divisible. | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 |
CommGroup.no_compact_automorphisms
{A : Type*} [CommGroup A] [TopologicalSpace A] [IsTopologicalGroup A]
[ConnectedSpace A] [CompactSpace A] [T2Space A] (K : Subgroup (ContinuousMonoidHom A A))
(hK : IsCompact (K : Set (ContinuousMonoidHom A A))) :
K = ⊥ | by
have A_rootable : RootableBy A ℕ := Group.rootable A
rw [eq_bot_iff]
intro f hf
ext a
rw [ContinuousMonoidHom.one_toFun]
by_contra! ha
let U : Set A := {f a}ᶜ
have hU : IsOpen U := isOpen_compl_singleton
have hU1 : 1 ∈ U := ha.symm
let W : Set (A →ₜ* A) := {f | Set.MapsTo f Set.univ U}
have hW ... | theorem | CommGroup.no_compact_automorphisms | Patching.Utils | FLT/Patching/Utils/CompactHausdorffRings.lean | [
"Mathlib.Data.Nat.Factorization.Induction",
"Mathlib.Topology.Algebra.Group.SubmonoidClosure",
"Mathlib.Topology.Algebra.Ring.Ideal"
] | [
"Group.rootable"
] | A connected compact Hausdorff abelian topological group does not admit a nontrivial compact
group of automorphisms. | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 |
Module.depth : ℕ∞ | sSup { List.length s | (s : List R)
(_ : Sequence.IsWeaklyRegular M s)
(_ : ∀ r ∈ s, r ∈ maximalIdeal R) } | def | Module.depth | Patching.Utils | FLT/Patching/Utils/Depth.lean | [
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.TensorProduct.Free",
"Mathlib.Tactic.Continuity.Init",
"Mathlib.Tactic.Positivity.Finset"
] | [] | Not sure if we should use `IsRegular` or `IsWeaklyRegular`.
They agree for nontrivial finite modules over local rings.
Using `IsWeaklyRegular` gives `depth R 0 = ∞`, which is the right one according to stacks. | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 |
Module.length_le_depth (s : List R)
(hs : Sequence.IsWeaklyRegular M s) (hs' : ∀ r ∈ s, r ∈ maximalIdeal R) :
s.length ≤ Module.depth R M | le_sSup ⟨s, hs, hs', rfl⟩ | lemma | Module.length_le_depth | Patching.Utils | FLT/Patching/Utils/Depth.lean | [
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.TensorProduct.Free",
"Mathlib.Tactic.Continuity.Init",
"Mathlib.Tactic.Positivity.Finset"
] | [
"Module.depth"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
Module.depth_of_subsingleton [Subsingleton M] :
Module.depth R M = ⊤ | by
rw [Module.depth, sSup_eq_top]
rintro b hb
obtain ⟨b, rfl⟩ := ENat.ne_top_iff_exists.mp hb.ne
simp only [Set.mem_setOf_eq, exists_prop, ↓existsAndEq, and_true, Nat.cast_lt]
refine ⟨List.replicate b.succ 0, ⟨?_, ?_⟩, ?_⟩
· refine (Sequence.isWeaklyRegular_iff_Fin ..).mpr fun i ↦ ?_
exact fun _ _ _ ↦ ... | lemma | Module.depth_of_subsingleton | Patching.Utils | FLT/Patching/Utils/Depth.lean | [
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.TensorProduct.Free",
"Mathlib.Tactic.Continuity.Init",
"Mathlib.Tactic.Positivity.Finset"
] | [
"Module.depth"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
Module.depth_of_isScalarTower :
Module.depth R M ≤ Module.depth S M | by
refine sSup_le_sSup ?_
rintro _ ⟨s, hs₁, hs₂, rfl⟩
rw [← Sequence.isWeaklyRegular_map_algebraMap_iff S M s] at hs₁
exact ⟨_, hs₁, by simpa, by simp⟩ | lemma | Module.depth_of_isScalarTower | Patching.Utils | FLT/Patching/Utils/Depth.lean | [
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.TensorProduct.Free",
"Mathlib.Tactic.Continuity.Init",
"Mathlib.Tactic.Positivity.Finset"
] | [
"Module.depth"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
Module.depth_le_krullDim_support [Nontrivial M] [Module.Finite R M] :
.some (Module.depth R M) ≤ Order.krullDim (Module.support R M) | by
have : Nonempty (Module.support R M) := by
rwa [Set.nonempty_coe_sort, Set.nonempty_iff_ne_empty,
ne_eq, support_eq_empty_iff, not_subsingleton_iff_nontrivial]
cases h : Order.krullDim (Module.support R M) with
| bot => simpa using Order.krullDim_nonneg.trans_eq h
| coe n =>
cases n with
| top ... | lemma | Module.depth_le_krullDim_support | Patching.Utils | FLT/Patching/Utils/Depth.lean | [
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.TensorProduct.Free",
"Mathlib.Tactic.Continuity.Init",
"Mathlib.Tactic.Positivity.Finset"
] | [
"Module.depth",
"Module.length_le_depth"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
Module.depth_le_dim_annihilator
[Nontrivial M] [Module.Finite R M] :
.some (Module.depth R M) ≤ ringKrullDim (R ⧸ Module.annihilator R M) | by
rw [ringKrullDim_quotient, ← Module.support_eq_zeroLocus]
exact Module.depth_le_krullDim_support _ _ | lemma | Module.depth_le_dim_annihilator | Patching.Utils | FLT/Patching/Utils/Depth.lean | [
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.TensorProduct.Free",
"Mathlib.Tactic.Continuity.Init",
"Mathlib.Tactic.Positivity.Finset"
] | [
"Module.depth",
"Module.depth_le_krullDim_support"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
Module.depth_le_dim [Nontrivial M] [Module.Finite R M] :
.some (Module.depth R M) ≤ ringKrullDim R | (depth_le_dim_annihilator R M).trans (ringKrullDim_quotient_le _) | lemma | Module.depth_le_dim | Patching.Utils | FLT/Patching/Utils/Depth.lean | [
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.TensorProduct.Free",
"Mathlib.Tactic.Continuity.Init",
"Mathlib.Tactic.Positivity.Finset"
] | [
"Module.depth"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
isSMulRegular_iff_of_free {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M]
[Module.Free R M] [Nontrivial M] {r : R} :
IsSMulRegular M r ↔ IsSMulRegular R r | by
let I := Module.Free.ChooseBasisIndex R M
let b : Module.Basis I R M := Module.Free.chooseBasis R M
constructor
· intro H m n h
have i : I := Nonempty.some inferInstance
have := @H (m • b i) (n • b i) (by simp_all [← mul_smul])
simpa using congr(b.repr $this i)
· intro H m n h
apply b.repr.... | lemma | isSMulRegular_iff_of_free | Patching.Utils | FLT/Patching/Utils/Depth.lean | [
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.TensorProduct.Free",
"Mathlib.Tactic.Continuity.Init",
"Mathlib.Tactic.Positivity.Finset"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
RingTheory.Sequence.isWeaklyRegular_of_subsingleton
{R : Type*} (M : Type*) [CommRing R] [AddCommGroup M] [Module R M]
[Subsingleton R] (s : List R) : Sequence.IsWeaklyRegular M s | have : Subsingleton M := Module.subsingleton R M
(isWeaklyRegular_iff_Fin ..).mpr fun _ _ _ _ ↦ Subsingleton.elim _ _ | lemma | RingTheory.Sequence.isWeaklyRegular_of_subsingleton | Patching.Utils | FLT/Patching/Utils/Depth.lean | [
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.TensorProduct.Free",
"Mathlib.Tactic.Continuity.Init",
"Mathlib.Tactic.Positivity.Finset"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
RingTheory.Sequence.isWeaklyRegular_of_free_aux
{R : Type u} {M : Type max u v} [CommRing R] [AddCommGroup M] [Module R M]
[Module.Free R M] [Nontrivial M] {s : List R} :
Sequence.IsWeaklyRegular M s ↔ Sequence.IsWeaklyRegular R s | by
generalize hn : s.length = n
induction n generalizing R M with
| zero => simp_all
| succ n IH =>
cases s with
| nil => simp at hn
| cons x xs =>
let e : QuotSMulTop x R ≃ₗ[R] R ⧸ Ideal.span {x} := Submodule.quotEquivOfEq _ _
(by rw [← Submodule.ideal_span_singleton_smul]; simp)
let ... | lemma | RingTheory.Sequence.isWeaklyRegular_of_free_aux | Patching.Utils | FLT/Patching/Utils/Depth.lean | [
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.TensorProduct.Free",
"Mathlib.Tactic.Continuity.Init",
"Mathlib.Tactic.Positivity.Finset"
] | [
"RingTheory.Sequence.isWeaklyRegular_of_subsingleton",
"isSMulRegular_iff_of_free"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
RingTheory.Sequence.isWeaklyRegular_of_free
{R M : Type*} [CommRing R] [AddCommGroup M] [Module R M]
[Module.Free R M] [Nontrivial M] {s : List R} :
Sequence.IsWeaklyRegular M s ↔ Sequence.IsWeaklyRegular R s | by
let b := Module.Free.chooseBasis R M
have : Nontrivial R := Module.nontrivial R M
rw [b.repr.isWeaklyRegular_congr, isWeaklyRegular_of_free_aux] | lemma | RingTheory.Sequence.isWeaklyRegular_of_free | Patching.Utils | FLT/Patching/Utils/Depth.lean | [
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.TensorProduct.Free",
"Mathlib.Tactic.Continuity.Init",
"Mathlib.Tactic.Positivity.Finset"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
Module.depth_le_of_free [Module.Free R M] : Module.depth R R ≤ Module.depth R M | by
cases subsingleton_or_nontrivial M
· simp [Module.depth_of_subsingleton]
apply sSup_le_sSup
rintro _ ⟨s, hs, hs', rfl⟩
refine ⟨s, Sequence.isWeaklyRegular_of_free.mpr hs, hs', rfl⟩ | lemma | Module.depth_le_of_free | Patching.Utils | FLT/Patching/Utils/Depth.lean | [
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.TensorProduct.Free",
"Mathlib.Tactic.Continuity.Init",
"Mathlib.Tactic.Positivity.Finset"
] | [
"Module.depth",
"Module.depth_of_subsingleton"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
Module.faithfulSMul_of_depth_eq_ringKrullDim [IsDomain R] [Nontrivial M] [Module.Finite R M]
(H : ringKrullDim R < ⊤) (H' : .some (Module.depth R M) = ringKrullDim R) :
FaithfulSMul R M | by
have : Nontrivial (R ⧸ annihilator R M) := Ideal.Quotient.nontrivial_iff.2
(by rw [ne_eq, ← Submodule.annihilator_top, Submodule.annihilator_eq_top_iff]
exact top_ne_bot)
rw [← Module.annihilator_eq_bot]
by_contra H''
apply (le_refl ((.some (Module.depth R M)) : WithBot ℕ∞)).not_gt
calc
_ ≤... | lemma | Module.faithfulSMul_of_depth_eq_ringKrullDim | Patching.Utils | FLT/Patching/Utils/Depth.lean | [
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.TensorProduct.Free",
"Mathlib.Tactic.Continuity.Init",
"Mathlib.Tactic.Positivity.Finset"
] | [
"Module.depth",
"Module.depth_le_dim_annihilator"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
dense_inverseLimit_of_forall_image_dense
(s : Set { v : Π i, α i // ∀ i j (h : i ≤ j), f i j h (v i) = v j })
(hs : ∀ i, Dense ((fun x ↦ (Subtype.val x) i) '' s)) : Dense s | by
classical
rw [dense_iff_inter_open]
rintro U ⟨t, ht, rfl⟩ ⟨x, hx⟩
obtain ⟨I, u, hu₁, hu₂⟩ := isOpen_pi_iff.mp ht _ hx
obtain ⟨i, hi⟩ := Finset.exists_le (α := ιᵒᵈ) I
let U : Set (α i) := ⋂ (j : I), (f _ _ (hi j.1 j.2)) ⁻¹' u _
have hU : IsOpen U := isOpen_iInter_of_finite fun j ↦ (hu₁ j.1 j.2).1.preima... | lemma | dense_inverseLimit_of_forall_image_dense | Patching.Utils | FLT/Patching/Utils/InverseLimit.lean | [
"Mathlib.CategoryTheory.CofilteredSystem",
"Mathlib.Data.Finset.Order"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
denseRange_inverseLimit {β}
(g : β → { v : Π i, α i // ∀ i j (h : i ≤ j), f i j h (v i) = v j })
(hg : ∀ i, DenseRange (fun x ↦ (g x).1 i)) : DenseRange g | by
refine dense_inverseLimit_of_forall_image_dense α f hf _ fun i ↦ ?_
rw [← Set.range_comp]
exact hg _ | lemma | denseRange_inverseLimit | Patching.Utils | FLT/Patching/Utils/InverseLimit.lean | [
"Mathlib.CategoryTheory.CofilteredSystem",
"Mathlib.Data.Finset.Order"
] | [
"dense_inverseLimit_of_forall_image_dense"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
nonempty_inverseLimit_of_finite [∀ i, Finite (α i)] [∀ i, Nonempty (α i)] :
Nonempty { v : Π i, α i // ∀ i j (h : i ≤ j), f i j h (v i) = v j } | by
let f' : ιᵒᵈᵒᵖ ⥤ Type _ :=
{ obj i := α i.1,
map e := ↾(f _ _ e.unop.le),
map_id i := by ext; simp [hf₀],
map_comp f g := by ext; simp [← hf _ _ _ f.unop.le g.unop.le] }
have : IsDirected ιᵒᵈ (· ≤ ·) := by
constructor
intros i j
obtain ⟨i', hi'⟩ := hl' i
obtain ⟨j', hj'⟩ := hl' j
... | theorem | nonempty_inverseLimit_of_finite | Patching.Utils | FLT/Patching/Utils/InverseLimit.lean | [
"Mathlib.CategoryTheory.CofilteredSystem",
"Mathlib.Data.Finset.Order"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
IsUnit.pi_iff {ι} {M : ι → Type*} [∀ i, Monoid (M i)] {x : Π i, M i} :
IsUnit x ↔ ∀ i, IsUnit (x i) | by
simp_rw [isUnit_iff_exists, funext_iff, ← forall_and]
exact Classical.skolem (p := fun i y ↦ x i * y = 1 ∧ y * x i = 1).symm | lemma | IsUnit.pi_iff | Patching.Utils | FLT/Patching/Utils/Lemmas.lean | [
"Mathlib.Data.Set.Card",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.Topology.Algebra.Module.Compact",
"Mathlib.Topology.Algebra.OpenSubgroup",
"Mathlib.Topology.Separation.Profinite"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
forall_prod_iff {ι} {β : ι → Type*} (P : ∀ i, β i → Prop) [∀ i, Nonempty (β i)] :
(∀ i : ι, ∀ (y : Π i, β i), P i (y i)) ↔ (∀ i y, P i y) | letI := Classical.decEq
⟨fun H i y ↦ by simpa using H i (fun j ↦ if h : i = j then h ▸ y else
Nonempty.some inferInstance), fun H i y ↦ H _ _⟩ | lemma | forall_prod_iff | Patching.Utils | FLT/Patching/Utils/Lemmas.lean | [
"Mathlib.Data.Set.Card",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.Topology.Algebra.Module.Compact",
"Mathlib.Topology.Algebra.OpenSubgroup",
"Mathlib.Topology.Separation.Profinite"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
Ideal.idealQuotientEquiv {R : Type*} [CommRing R] (I : Ideal R) :
Ideal (R ⧸ I) ≃ { J // I ≤ J } | where
toFun J := ⟨J.comap (Ideal.Quotient.mk I),
(I.mk_ker : _).symm.trans_le (Ideal.comap_mono bot_le)⟩
invFun J := J.1.map (Ideal.Quotient.mk I)
left_inv J := map_comap_of_surjective _ Quotient.mk_surjective _
right_inv J := by
ext1
simpa [comap_map_of_surjective _ Quotient.mk_surjec... | def | Ideal.idealQuotientEquiv | Patching.Utils | FLT/Patching/Utils/Lemmas.lean | [
"Mathlib.Data.Set.Card",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.Topology.Algebra.Module.Compact",
"Mathlib.Topology.Algebra.OpenSubgroup",
"Mathlib.Topology.Separation.Profinite"
] | [] | Bijection between ideals of `R / I` and ideals of `R` containing `I`, via comap/map
along the quotient map. | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 |
Submodule.pi' : Submodule (Π i, R i) (Π i, M i) | where
carrier := { x | ∀ i, x i ∈ N i }
add_mem' := by aesop
zero_mem' := by aesop
smul_mem' := by aesop | def | Submodule.pi' | Patching.Utils | FLT/Patching/Utils/Lemmas.lean | [
"Mathlib.Data.Set.Card",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.Topology.Algebra.Module.Compact",
"Mathlib.Topology.Algebra.OpenSubgroup",
"Mathlib.Topology.Separation.Profinite"
] | [] | The product of a family of submodules `N i ≤ M i`, viewed as a submodule of
`Π i, M i` over the product ring `Π i, R i`. | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 |
Submodule.mem_pi' {x} : x ∈ Submodule.pi' N ↔ ∀ i, x i ∈ N i | Iff.rfl | lemma | Submodule.mem_pi' | Patching.Utils | FLT/Patching/Utils/Lemmas.lean | [
"Mathlib.Data.Set.Card",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.Topology.Algebra.Module.Compact",
"Mathlib.Topology.Algebra.OpenSubgroup",
"Mathlib.Topology.Separation.Profinite"
] | [
"Submodule.pi'"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
LinearMap.piMap' (f : ∀ i, M i →ₗ[R i] N i) : (Π i, M i) →ₗ[Π i, R i] Π i, N i | where
toFun g i := f i (g i)
map_add' := by aesop
map_smul' := by aesop | def | LinearMap.piMap' | Patching.Utils | FLT/Patching/Utils/Lemmas.lean | [
"Mathlib.Data.Set.Card",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.Topology.Algebra.Module.Compact",
"Mathlib.Topology.Algebra.OpenSubgroup",
"Mathlib.Topology.Separation.Profinite"
] | [] | A more dependent version of `LinearMap.piMap`, making a product of linear maps
into a linear map over the product of rings. | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 |
pi'_jacobson :
Submodule.pi' (fun i ↦ Ideal.jacobson (R := R i) ⊥) = Ideal.jacobson ⊥ | by
ext v
simp only [Submodule.mem_pi', Ideal.mem_jacobson_bot, IsUnit.pi_iff]
conv_rhs => rw [forall_comm]
exact (forall_prod_iff (fun i y ↦ IsUnit (v i * y + 1))).symm | lemma | pi'_jacobson | Patching.Utils | FLT/Patching/Utils/Lemmas.lean | [
"Mathlib.Data.Set.Card",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.Topology.Algebra.Module.Compact",
"Mathlib.Topology.Algebra.OpenSubgroup",
"Mathlib.Topology.Separation.Profinite"
] | [
"IsUnit.pi_iff",
"Submodule.mem_pi'",
"Submodule.pi'",
"forall_prod_iff"
] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
exists_subgroup_isOpen_and_subset {α : Type*} [TopologicalSpace α]
[CompactSpace α] [T2Space α] [TotallyDisconnectedSpace α]
[CommGroup α] [IsTopologicalGroup α] {U : Set α} (hU : U ∈ 𝓝 1) :
∃ G : Subgroup α, IsOpen (X := α) G ∧ (G : Set α) ⊆ U | by
obtain ⟨V, hVU, hV, h1V⟩ := mem_nhds_iff.mp hU
obtain ⟨K, hK, hxK, hKU⟩ := compact_exists_isClopen_in_isOpen hV h1V
obtain ⟨⟨G, hG⟩, hG'⟩ := IsTopologicalGroup.exist_openSubgroup_sub_clopen_nhds_of_one hK hxK
exact ⟨G, hG, (hG'.trans hKU).trans hVU⟩ | theorem | exists_subgroup_isOpen_and_subset | Patching.Utils | FLT/Patching/Utils/Lemmas.lean | [
"Mathlib.Data.Set.Card",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.Topology.Algebra.Module.Compact",
"Mathlib.Topology.Algebra.OpenSubgroup",
"Mathlib.Topology.Separation.Profinite"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
TwoSidedIdeal.span_le' {α} [NonUnitalNonAssocRing α] {s : Set α} {I : TwoSidedIdeal α} :
span s ≤ I ↔ s ⊆ I | ⟨subset_span.trans, fun h _ hx ↦ mem_span_iff.mp hx I h⟩ | theorem | TwoSidedIdeal.span_le' | Patching.Utils | FLT/Patching/Utils/Lemmas.lean | [
"Mathlib.Data.Set.Card",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.Topology.Algebra.Module.Compact",
"Mathlib.Topology.Algebra.OpenSubgroup",
"Mathlib.Topology.Separation.Profinite"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
TwoSidedIdeal.span_neg {α} [NonUnitalNonAssocRing α] (s : Set α) :
TwoSidedIdeal.span (-s) = TwoSidedIdeal.span s | by
apply le_antisymm <;> rw [span_le']
· rintro x hx
exact neg_neg x ▸ neg_mem _ (subset_span (s := s) hx)
· rintro x hx
exact neg_neg x ▸ neg_mem _ (subset_span (Set.neg_mem_neg.mpr hx)) | theorem | TwoSidedIdeal.span_neg | Patching.Utils | FLT/Patching/Utils/Lemmas.lean | [
"Mathlib.Data.Set.Card",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.Topology.Algebra.Module.Compact",
"Mathlib.Topology.Algebra.OpenSubgroup",
"Mathlib.Topology.Separation.Profinite"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
TwoSidedIdeal.span_singleton_zero {α} [NonUnitalNonAssocRing α] :
span {(0 : α)} = ⊥ | le_bot_iff.mp (span_le'.mpr (by simp)) | theorem | TwoSidedIdeal.span_singleton_zero | Patching.Utils | FLT/Patching/Utils/Lemmas.lean | [
"Mathlib.Data.Set.Card",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.Topology.Algebra.Module.Compact",
"Mathlib.Topology.Algebra.OpenSubgroup",
"Mathlib.Topology.Separation.Profinite"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
TwoSidedIdeal.mem_span_singleton {α} [NonUnitalNonAssocRing α] {x : α} :
x ∈ span {x} | subset_span rfl | theorem | TwoSidedIdeal.mem_span_singleton | Patching.Utils | FLT/Patching/Utils/Lemmas.lean | [
"Mathlib.Data.Set.Card",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.Topology.Algebra.Module.Compact",
"Mathlib.Topology.Algebra.OpenSubgroup",
"Mathlib.Topology.Separation.Profinite"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 | |
TwoSidedIdeal.leAddSubgroup {α} [NonUnitalNonAssocRing α] (G : AddSubgroup α) :
TwoSidedIdeal α | .mk'
{ x | (span {x} : Set α) ⊆ G }
-- TODO: `TwoSidedIdeal.span` shouldn't be an `abbrev`!!
(by simp [-coe_mk, G.zero_mem])
(fun {x y} hx hy ↦ by
have : span {x + y} ≤ span {x} ⊔ span {y} :=
span_le'.mpr <| Set.singleton_subset_iff.mpr <|
mem_sup.mpr ⟨x, mem_span_singleton, y, m... | def | TwoSidedIdeal.leAddSubgroup | Patching.Utils | FLT/Patching/Utils/Lemmas.lean | [
"Mathlib.Data.Set.Card",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.Topology.Algebra.Module.Compact",
"Mathlib.Topology.Algebra.OpenSubgroup",
"Mathlib.Topology.Separation.Profinite"
] | [
"TwoSidedIdeal.span_neg",
"coe_mk"
] | The largest two-sided ideal contained in a given additive subgroup `G ≤ α`:
those `x ∈ α` whose two-sided span is contained in `G`. | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 |
TwoSidedIdeal.leAddSubgroup_subset {α} [NonUnitalNonAssocRing α] (G : AddSubgroup α) :
(leAddSubgroup G : Set α) ⊆ G | fun x hx ↦ hx ((sub_zero x).symm ▸ mem_span_singleton) | lemma | TwoSidedIdeal.leAddSubgroup_subset | Patching.Utils | FLT/Patching/Utils/Lemmas.lean | [
"Mathlib.Data.Set.Card",
"Mathlib.Data.SetLike.Fintype",
"Mathlib.RingTheory.Filtration",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.Topology.Algebra.Module.Compact",
"Mathlib.Topology.Algebra.OpenSubgroup",
"Mathlib.Topology.Separation.Profinite"
] | [] | https://github.com/ImperialCollegeLondon/FLT | 6cffefeb368ca4cfabc907f86f96783a49ae4033 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.