fact stringlengths 19 5.66k | type stringclasses 8
values | library stringclasses 2
values | imports listlengths 1 14 | filename stringclasses 160
values | symbolic_name stringlengths 1 92 | docstring stringlengths 12 499 ⌀ |
|---|---|---|---|---|---|---|
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.krull... | lemma | FLT | [
"import Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"import Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"import Mathlib.RingTheory.Regular.RegularSequence",
"import Mathlib.RingTheory.Spectrum.Prime.Topology",
"import Mathlib.RingTheory.Support",
"import Mathlib.RingTheory.TensorProduct.Free"
] | FLT/Patching/Utils/Depth.lean | Module.depth_le_krullDim_support | null |
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 | FLT | [
"import Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"import Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"import Mathlib.RingTheory.Regular.RegularSequence",
"import Mathlib.RingTheory.Spectrum.Prime.Topology",
"import Mathlib.RingTheory.Support",
"import Mathlib.RingTheory.TensorProduct.Free"
] | FLT/Patching/Utils/Depth.lean | Module.depth_le_dim_annihilator | null |
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 | FLT | [
"import Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"import Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"import Mathlib.RingTheory.Regular.RegularSequence",
"import Mathlib.RingTheory.Spectrum.Prime.Topology",
"import Mathlib.RingTheory.Support",
"import Mathlib.RingTheory.TensorProduct.Free"
] | FLT/Patching/Utils/Depth.lean | Module.depth_le_dim | null |
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 := Nonempty.som... | lemma | FLT | [
"import Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"import Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"import Mathlib.RingTheory.Regular.RegularSequence",
"import Mathlib.RingTheory.Spectrum.Prime.Topology",
"import Mathlib.RingTheory.Support",
"import Mathlib.RingTheory.TensorProduct.Free"
] | FLT/Patching/Utils/Depth.lean | isSMulRegular_iff_of_free | null |
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 _ _ universe u v in ope... | lemma | FLT | [
"import Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"import Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"import Mathlib.RingTheory.Regular.RegularSequence",
"import Mathlib.RingTheory.Spectrum.Prime.Topology",
"import Mathlib.RingTheory.Support",
"import Mathlib.RingTheory.TensorProduct.Free"
] | FLT/Patching/Utils/Depth.lean | RingTheory.Sequence.isWeaklyRegular_of_subsingleton | null |
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 |... | lemma | FLT | [
"import Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"import Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"import Mathlib.RingTheory.Regular.RegularSequence",
"import Mathlib.RingTheory.Spectrum.Prime.Topology",
"import Mathlib.RingTheory.Support",
"import Mathlib.RingTheory.TensorProduct.Free"
] | FLT/Patching/Utils/Depth.lean | RingTheory.Sequence.isWeaklyRegular_of_free_aux | null |
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.isWeaklyRegu... | lemma | FLT | [
"import Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"import Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"import Mathlib.RingTheory.Regular.RegularSequence",
"import Mathlib.RingTheory.Spectrum.Prime.Topology",
"import Mathlib.RingTheory.Support",
"import Mathlib.RingTheory.TensorProduct.Free"
] | FLT/Patching/Utils/Depth.lean | RingTheory.Sequence.isWeaklyRegular_of_free | null |
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 | FLT | [
"import Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"import Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"import Mathlib.RingTheory.Regular.RegularSequence",
"import Mathlib.RingTheory.Spectrum.Prime.Topology",
"import Mathlib.RingTheory.Support",
"import Mathlib.RingTheory.TensorProduct.Free"
] | FLT/Patching/Utils/Depth.lean | Module.depth_le_of_free | null |
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... | lemma | FLT | [
"import Mathlib.RingTheory.Flat.FaithfullyFlat.Basic",
"import Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"import Mathlib.RingTheory.Regular.RegularSequence",
"import Mathlib.RingTheory.Spectrum.Prime.Topology",
"import Mathlib.RingTheory.Support",
"import Mathlib.RingTheory.TensorProduct.Free"
] | FLT/Patching/Utils/Depth.lean | Module.faithfulSMul_of_depth_eq_ringKrullDim | null |
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⟩ := Finse... | lemma | FLT | [
"import Mathlib.CategoryTheory.CofilteredSystem",
"import Mathlib.Data.Finset.Order"
] | FLT/Patching/Utils/InverseLimit.lean | dense_inverseLimit_of_forall_image_dense | null |
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 | FLT | [
"import Mathlib.CategoryTheory.CofilteredSystem",
"import Mathlib.Data.Finset.Order"
] | FLT/Patching/Utils/InverseLimit.lean | denseRange_inverseLimit | null |
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] } hav... | theorem | FLT | [
"import Mathlib.CategoryTheory.CofilteredSystem",
"import Mathlib.Data.Finset.Order"
] | FLT/Patching/Utils/InverseLimit.lean | nonempty_inverseLimit_of_finite | null |
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 | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | IsUnit.pi_iff | null |
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 _ _⟩ @[simps] | lemma | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | forall_prod_iff | null |
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... | def | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | Ideal.idealQuotientEquiv | null |
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 variable {N} in @[simp] | def | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | Submodule.pi' | null |
Submodule.mem_pi' {x} : x ∈ Submodule.pi' N ↔ ∀ i, x i ∈ N i := Iff.rfl variable {N : ι → Type*} [∀ i, AddCommGroup (N i)] [∀ i, Module (R i) (N i)] in @[simps] | lemma | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | Submodule.mem_pi' | null |
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 | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | LinearMap.piMap | null |
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 | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | pi'_jacobson | null |
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, h... | theorem | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | exists_subgroup_isOpen_and_subset | null |
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⟩ @[simp] | theorem | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | TwoSidedIdeal.span_le' | null |
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)) @[simp] | theorem | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | TwoSidedIdeal.span_neg | null |
TwoSidedIdeal.span_singleton_zero {α} [NonUnitalNonAssocRing α] : span {(0 : α)} = ⊥ := le_bot_iff.mp (span_le'.mpr (by simp)) | theorem | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | TwoSidedIdeal.span_singleton_zero | null |
TwoSidedIdeal.mem_span_singleton {α} [NonUnitalNonAssocRing α] {x : α} : x ∈ span {x} := subset_span rfl | theorem | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | TwoSidedIdeal.mem_span_singleton | null |
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... | def | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | TwoSidedIdeal.leAddSubgroup | null |
TwoSidedIdeal.leAddSubgroup_subset {α} [NonUnitalNonAssocRing α] (G : AddSubgroup α) : (leAddSubgroup G : Set α) ⊆ G := fun x hx ↦ hx ((sub_zero x).symm ▸ mem_span_singleton) | lemma | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | TwoSidedIdeal.leAddSubgroup_subset | null |
TwoSidedIdeal.mem_leAddSubgroup' {α} [NonUnitalNonAssocRing α] {G : AddSubgroup α} {x : α} : x ∈ leAddSubgroup G ↔ (span {x} : Set α) ⊆ G := by conv_rhs => rw [← sub_zero x] rfl | lemma | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | TwoSidedIdeal.mem_leAddSubgroup' | null |
TwoSidedIdeal.mem_leAddSubgroup {α} [Ring α] {G : AddSubgroup α} {x : α} : x ∈ leAddSubgroup G ↔ ∀ a b, a * x * b ∈ G := by constructor · intro hx a b exact hx (mul_mem_right _ _ _ (mul_mem_left _ _ _ ((sub_zero x).symm ▸ mem_span_singleton))) · intro H a ha simpa using mem_span_iff.mp ha (.mk' { x | ∀ a b, a * x * b ∈... | lemma | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | TwoSidedIdeal.mem_leAddSubgroup | null |
exists_twoSidedIdeal_isOpen_and_subset {α} [TopologicalSpace α] [CompactSpace α] [T2Space α] [TotallyDisconnectedSpace α] [Ring α] [IsTopologicalRing α] {U : Set α} (hU : U ∈ 𝓝 0) : ∃ I : TwoSidedIdeal α, IsOpen (X := α) I ∧ (I : Set α) ⊆ U := by obtain ⟨G, hG, hGU⟩ := exists_addSubgroup_isOpen_and_subset hU refine ⟨_... | theorem | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | exists_twoSidedIdeal_isOpen_and_subset | null |
exists_ideal_isOpen_and_subset {α} [TopologicalSpace α] [CompactSpace α] [T2Space α] [TotallyDisconnectedSpace α] [Ring α] [IsTopologicalRing α] {U : Set α} (hU : U ∈ 𝓝 0) : ∃ I : Ideal α, IsOpen (X := α) I ∧ (I : Set α) ⊆ U := by obtain ⟨I, hI, hIU⟩ := exists_twoSidedIdeal_isOpen_and_subset hU exact ⟨I.asIdeal, hI, h... | theorem | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | exists_ideal_isOpen_and_subset | null |
WellFoundedGT.exists_eq_sup {α} [CompleteLattice α] [WellFoundedGT α] (f : ℕ →o α) : ∃ i, f i = ⨆ i, f i := by obtain ⟨n, hn⟩ := wellFoundedGT_iff_monotone_chain_condition.mp ‹WellFoundedGT α› f exact ⟨n, le_antisymm (le_iSup _ _) (iSup_le fun i ↦ (le_total i n).elim (f.2 ·) (fun h ↦ (hn _ h).ge))⟩ | lemma | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | WellFoundedGT.exists_eq_sup | null |
WellFoundedLT.exists_eq_inf {α} [CompleteLattice α] [WellFoundedLT α] (f : ℕ →o αᵒᵈ) : ∃ i, f i = (⨅ i, f i : α) := WellFoundedGT.exists_eq_sup (α := αᵒᵈ) f | lemma | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | WellFoundedLT.exists_eq_inf | null |
IsLocalRing.maximalIdeal_pow_card_smul_top_le {R M} [CommRing R] [IsLocalRing R] [IsNoetherianRing R] [AddCommGroup M] [Module R M] (N : Submodule R M) [Finite (M ⧸ N)] : maximalIdeal R ^ Nat.card (M ⧸ N) • ⊤ ≤ N := by let f (n) : Submodule R (M ⧸ N) := maximalIdeal R ^ n • ⊤ have hf : ∀ i j, i ≤ j → f j ≤ f i := fun i... | lemma | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | IsLocalRing.maximalIdeal_pow_card_smul_top_le | null |
Submodule.comap_smul_of_le_range {R M M'} [CommRing R] [AddCommGroup M] [AddCommGroup M'] [Module R M] [Module R M'] (f : M →ₗ[R] M') (S : Submodule R M') (hS : S ≤ LinearMap.range f) (I : Ideal R) : (I • S).comap f = (I • S.comap f) ⊔ LinearMap.ker f := by rw [← comap_map_eq, map_smul'', Submodule.map_comap_eq, inf_eq... | theorem | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | Submodule.comap_smul_of_le_range | null |
Submodule.comap_smul_of_surjective {R M M'} [CommRing R] [AddCommGroup M] [AddCommGroup M'] [Module R M] [Module R M'] (f : M →ₗ[R] M') (S : Submodule R M') (hS : Function.Surjective f) (I : Ideal R) : (I • S).comap f = (I • S.comap f) ⊔ LinearMap.ker f := comap_smul_of_le_range f S (le_top.trans_eq (LinearMap.range_eq... | theorem | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | Submodule.comap_smul_of_surjective | null |
Pi.liftQuotientₗ {ι R M : Type*} [CommRing R] [AddCommGroup M] [Module R M] [Finite ι] (f : (ι → R) →ₗ[R] M) (I : Ideal R) : (ι → R ⧸ I) →ₗ[R] M ⧸ (I • ⊤ : Submodule R M) := by refine Submodule.liftQ _ (Submodule.mkQ _ ∘ₗ f) ?_ ∘ₗ (((Algebra.linearMap R (R ⧸ I)).compLeft ι).quotKerEquivOfSurjective ?_).symm.toLinearMap... | def | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | Pi.liftQuotientₗ | null |
Pi.liftQuotientₗ_surjective {ι R M : Type*} [CommRing R] [AddCommGroup M] [Module R M] [Finite ι] (f : (ι → R) →ₗ[R] M) (I : Ideal R) (hf : Function.Surjective f) : Function.Surjective (Pi.liftQuotientₗ f I) := by simp only [liftQuotientₗ, LinearMap.coe_comp, LinearEquiv.coe_coe, EquivLike.surjective_comp] rw [← Linear... | lemma | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | Pi.liftQuotientₗ_surjective | null |
Pi.liftQuotientₗ_bijective {ι R M : Type*} [CommRing R] [AddCommGroup M] [Module R M] [Finite ι] (f : (ι → R) →ₗ[R] M) (I : Ideal R) (hf : Function.Surjective f) (hf' : LinearMap.ker f ≤ LinearMap.ker ((Algebra.linearMap R (R ⧸ I)).compLeft ι)) : Function.Bijective (Pi.liftQuotientₗ f I) := by refine ⟨?_, liftQuotientₗ... | lemma | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | Pi.liftQuotientₗ_bijective | null |
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 := letI : ContinuousAdd M := toContinuousAdd R M ⟨Submodule.isCompact_of_fg (Module.Finite.fg_top (R := R))⟩ | lemma | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | IsModuleTopology.compactSpace | null |
disjoint_nonZeroDivisors_of_mem_minimalPrimes {R : Type*} [CommRing R] (p : Ideal R) (hp : p ∈ minimalPrimes R) : Disjoint (p : Set R) (nonZeroDivisors R) := by classical rw [← Set.subset_compl_iff_disjoint_right, Set.subset_def] simp only [SetLike.mem_coe, Set.mem_compl_iff, mem_nonZeroDivisors_iff_right, not_forall] ... | lemma | FLT | [
"import Mathlib.RingTheory.Filtration",
"import Mathlib.Topology.Algebra.Module.Compact",
"import Mathlib.Topology.Algebra.Module.ModuleTopology",
"import Mathlib.Topology.Algebra.OpenSubgroup",
"import Mathlib.Topology.Algebra.Ring.Ideal",
"import Mathlib.Topology.Separation.Profinite",
"import Mathlib... | FLT/Patching/Utils/Lemmas.lean | disjoint_nonZeroDivisors_of_mem_minimalPrimes | null |
ModuleTypeCardLT (N : ℕ) : Type _ := Σ (n : Fin N) (_ : AddCommGroup (Fin n)), Module R (Fin n) | def | FLT | [
"import FLT.Patching.Utils.TopologicallyFG",
"import Mathlib.Algebra.Ring.Ext",
"import Mathlib.Topology.Algebra.Module.Equiv",
"import Mathlib.Algebra.Ring.TransferInstance",
"import Mathlib.Algebra.Algebra.TransferInstance"
] | FLT/Patching/Utils/StructureFiniteness.lean | ModuleTypeCardLT | null |
ModuleTypeCardLT.ofModule (N : ℕ) (M : Type*) [AddCommGroup M] [Module R M] [Finite M] (hM : Nat.card M < N) : ModuleTypeCardLT R N := ⟨⟨Nat.card M, hM⟩, (Finite.equivFin M).symm.addCommGroup, (Finite.equivFin M).symm.module R⟩ | def | FLT | [
"import FLT.Patching.Utils.TopologicallyFG",
"import Mathlib.Algebra.Ring.Ext",
"import Mathlib.Topology.Algebra.Module.Equiv",
"import Mathlib.Algebra.Ring.TransferInstance",
"import Mathlib.Algebra.Algebra.TransferInstance"
] | FLT/Patching/Utils/StructureFiniteness.lean | ModuleTypeCardLT.ofModule | null |
ModuleTypeCardLT.equivOfModule (N : ℕ) {M : Type*} [AddCommGroup M] [Module R M] [Finite M] (hM : Nat.card M < N) : M ≃ₗ[R] Fin ((ModuleTypeCardLT.ofModule R N M hM).1) := ((show M ≃ Fin ((ModuleTypeCardLT.ofModule R N M hM).1) from Finite.equivFin M).symm.linearEquiv R).symm | def | FLT | [
"import FLT.Patching.Utils.TopologicallyFG",
"import Mathlib.Algebra.Ring.Ext",
"import Mathlib.Topology.Algebra.Module.Equiv",
"import Mathlib.Algebra.Ring.TransferInstance",
"import Mathlib.Algebra.Algebra.TransferInstance"
] | FLT/Patching/Utils/StructureFiniteness.lean | ModuleTypeCardLT.equivOfModule | null |
AlgebraTypeCardLT (N : ℕ) : Type _ := Σ (n : Fin N) (_ : Ring (Fin n)), Algebra R (Fin n) | def | FLT | [
"import FLT.Patching.Utils.TopologicallyFG",
"import Mathlib.Algebra.Ring.Ext",
"import Mathlib.Topology.Algebra.Module.Equiv",
"import Mathlib.Algebra.Ring.TransferInstance",
"import Mathlib.Algebra.Algebra.TransferInstance"
] | FLT/Patching/Utils/StructureFiniteness.lean | AlgebraTypeCardLT | null |
AlgebraTypeCardLT.ofAlgebra (N : ℕ) (M : Type*) [Ring M] [Algebra R M] [Finite M] (hM : Nat.card M < N) : AlgebraTypeCardLT R N := ⟨⟨Nat.card M, hM⟩, (Finite.equivFin M).symm.ring, (Finite.equivFin M).symm.algebra R⟩ | def | FLT | [
"import FLT.Patching.Utils.TopologicallyFG",
"import Mathlib.Algebra.Ring.Ext",
"import Mathlib.Topology.Algebra.Module.Equiv",
"import Mathlib.Algebra.Ring.TransferInstance",
"import Mathlib.Algebra.Algebra.TransferInstance"
] | FLT/Patching/Utils/StructureFiniteness.lean | AlgebraTypeCardLT.ofAlgebra | null |
AlgebraTypeCardLT.equivOfAlgebra (N : ℕ) {M : Type*} [Ring M] [Algebra R M] [Finite M] (hM : Nat.card M < N) : M ≃ₐ[R] Fin ((AlgebraTypeCardLT.ofAlgebra R N M hM).1) := ((show M ≃ Fin ((AlgebraTypeCardLT.ofAlgebra R N M hM).1) from Finite.equivFin M).symm.algEquiv R).symm | def | FLT | [
"import FLT.Patching.Utils.TopologicallyFG",
"import Mathlib.Algebra.Ring.Ext",
"import Mathlib.Topology.Algebra.Module.Equiv",
"import Mathlib.Algebra.Ring.TransferInstance",
"import Mathlib.Algebra.Algebra.TransferInstance"
] | FLT/Patching/Utils/StructureFiniteness.lean | AlgebraTypeCardLT.equivOfAlgebra | null |
TopologicalModuleTypeCardLT (N : ℕ) : Type _ := Σ' (n : Fin N) (_ : AddCommGroup (Fin n)) (_ : TopologicalSpace (Fin n)) (_ : T2Space (Fin n)) (_ : Module R (Fin n)), ContinuousSMul R (Fin n) | def | FLT | [
"import FLT.Patching.Utils.TopologicallyFG",
"import Mathlib.Algebra.Ring.Ext",
"import Mathlib.Topology.Algebra.Module.Equiv",
"import Mathlib.Algebra.Ring.TransferInstance",
"import Mathlib.Algebra.Algebra.TransferInstance"
] | FLT/Patching/Utils/StructureFiniteness.lean | TopologicalModuleTypeCardLT | null |
TopologicalModuleTypeCardLT.ofModule (N : ℕ) (M : Type*) [AddCommGroup M] [Module R M] [TopologicalSpace M] [T2Space M] [ContinuousSMul R M] [Finite M] (hM : Nat.card M < N) : TopologicalModuleTypeCardLT R N := ⟨⟨Nat.card M, hM⟩, (Finite.equivFin M).symm.addCommGroup, .coinduced (Finite.equivFin M) inferInstance, letI ... | def | FLT | [
"import FLT.Patching.Utils.TopologicallyFG",
"import Mathlib.Algebra.Ring.Ext",
"import Mathlib.Topology.Algebra.Module.Equiv",
"import Mathlib.Algebra.Ring.TransferInstance",
"import Mathlib.Algebra.Algebra.TransferInstance"
] | FLT/Patching/Utils/StructureFiniteness.lean | TopologicalModuleTypeCardLT.ofModule | null |
TopologicalModuleTypeCardLT.equivOfModule (N : ℕ) (M : Type*) [AddCommGroup M] [Module R M] [TopologicalSpace M] [T2Space M] [ContinuousSMul R M] [Finite M] (hM : Nat.card M < N) : M ≃L[R] Fin (TopologicalModuleTypeCardLT.ofModule R N M hM).1 where __ := ((show M ≃ Fin ((ModuleTypeCardLT.ofModule R N M hM).1) from Fini... | def | FLT | [
"import FLT.Patching.Utils.TopologicallyFG",
"import Mathlib.Algebra.Ring.Ext",
"import Mathlib.Topology.Algebra.Module.Equiv",
"import Mathlib.Algebra.Ring.TransferInstance",
"import Mathlib.Algebra.Algebra.TransferInstance"
] | FLT/Patching/Utils/StructureFiniteness.lean | TopologicalModuleTypeCardLT.equivOfModule | null |
TopologicalAlgebraTypeCardLT [IsTopologicalRing R] [Algebra.TopologicallyFG ℤ R] (N : ℕ) : Type _ := Σ' (n : Fin N) (_ : Ring (Fin n)) (_ : TopologicalSpace (Fin n)) (_ : T2Space (Fin n)) (_ : Algebra R (Fin n)), ContinuousSMul R (Fin n) | def | FLT | [
"import FLT.Patching.Utils.TopologicallyFG",
"import Mathlib.Algebra.Ring.Ext",
"import Mathlib.Topology.Algebra.Module.Equiv",
"import Mathlib.Algebra.Ring.TransferInstance",
"import Mathlib.Algebra.Algebra.TransferInstance"
] | FLT/Patching/Utils/StructureFiniteness.lean | TopologicalAlgebraTypeCardLT | null |
TopologicalAlgebraTypeCardLT.ofAlgebra (N : ℕ) (M : Type*) [Ring M] [Algebra R M] [TopologicalSpace M] [T2Space M] [ContinuousSMul R M] [Finite M] (hM : Nat.card M < N) : TopologicalAlgebraTypeCardLT R N := ⟨⟨Nat.card M, hM⟩, (Finite.equivFin M).symm.ring, .coinduced (Finite.equivFin M) inferInstance, letI := Topologic... | def | FLT | [
"import FLT.Patching.Utils.TopologicallyFG",
"import Mathlib.Algebra.Ring.Ext",
"import Mathlib.Topology.Algebra.Module.Equiv",
"import Mathlib.Algebra.Ring.TransferInstance",
"import Mathlib.Algebra.Algebra.TransferInstance"
] | FLT/Patching/Utils/StructureFiniteness.lean | TopologicalAlgebraTypeCardLT.ofAlgebra | null |
TopologicalAlgebraTypeCardLT.equivOfAlgebra (N : ℕ) (M : Type*) [Ring M] [Algebra R M] [TopologicalSpace M] [T2Space M] [ContinuousSMul R M] [Finite M] (hM : Nat.card M < N) : M ≃ₐ[R] Fin (TopologicalAlgebraTypeCardLT.ofAlgebra R N M hM).1 := ((show M ≃ Fin ((AlgebraTypeCardLT.ofAlgebra R N M hM).1) from Finite.equivFi... | def | FLT | [
"import FLT.Patching.Utils.TopologicallyFG",
"import Mathlib.Algebra.Ring.Ext",
"import Mathlib.Topology.Algebra.Module.Equiv",
"import Mathlib.Algebra.Ring.TransferInstance",
"import Mathlib.Algebra.Algebra.TransferInstance"
] | FLT/Patching/Utils/StructureFiniteness.lean | TopologicalAlgebraTypeCardLT.equivOfAlgebra | null |
TopologicalAlgebraTypeCardLT.isHomeomorph_equivOfAlgebra (N : ℕ) (M : Type*) [Ring M] [Algebra R M] [TopologicalSpace M] [T2Space M] [ContinuousSMul R M] [Finite M] (hM : Nat.card M < N) : IsHomeomorph (equivOfAlgebra (R := R) N M hM) := ((Finite.equivFin M).toHomeomorph (Y := Fin (ofAlgebra R N M hM).1) (fun _ ↦ Iff.r... | lemma | FLT | [
"import FLT.Patching.Utils.TopologicallyFG",
"import Mathlib.Algebra.Ring.Ext",
"import Mathlib.Topology.Algebra.Module.Equiv",
"import Mathlib.Algebra.Ring.TransferInstance",
"import Mathlib.Algebra.Algebra.TransferInstance"
] | FLT/Patching/Utils/StructureFiniteness.lean | TopologicalAlgebraTypeCardLT.isHomeomorph_equivOfAlgebra | null |
Algebra.TopologicallyFG [IsTopologicalRing S] : Prop where out : ∃ s : Finset S, Dense (Algebra.adjoin R (s : Set S) : Set S) | class | FLT | [
"import Mathlib.RingTheory.FiniteType",
"import Mathlib.Topology.Algebra.Ring.Basic"
] | FLT/Patching/Utils/TopologicallyFG.lean | Algebra.TopologicallyFG | null |
Algebra.TopologicallyFG.module_ext (s : Set S) (hs' : Dense (Algebra.adjoin R (s : Set S) : Set S)) {m₁ m₂ : Module S M} (hm₁ : letI := m₁; IsScalarTower R S M) (hm₂ : letI := m₂; IsScalarTower R S M) (hm₁' : letI := m₁; ContinuousSMul S M) (hm₂' : letI := m₂; ContinuousSMul S M) (H : ∀ x ∈ s, ∀ m : M, (letI := m₁; x •... | lemma | FLT | [
"import Mathlib.RingTheory.FiniteType",
"import Mathlib.Topology.Algebra.Ring.Basic"
] | FLT/Patching/Utils/TopologicallyFG.lean | Algebra.TopologicallyFG.module_ext | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.