fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
π_comp_H2Iso_hom :
π A 2 ≫ (H2Iso A).hom = (isoCycles₂ A).hom ≫
(shortComplexH2 A).moduleCatLeftHomologyData.π := by
simp [H2Iso, isoCycles₂, π, HomologicalComplex.homologyπ, leftHomologyπ]
@[reassoc (attr := simp), elementwise (attr := simp)] | lemma | RepresentationTheory | [
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.RepresentationTheory.Homological.GroupHomology.Basic",
"Mathlib.RepresentationTheory.Invariants"
] | Mathlib/RepresentationTheory/Homological/GroupHomology/LowDegree.lean | π_comp_H2Iso_hom | null |
π_comp_H2Iso_inv :
(shortComplexH2 A).moduleCatLeftHomologyData.π ≫ (H2Iso A).inv = H2π A :=
(CommSq.vert_inv ⟨π_comp_H2Iso_hom A⟩).w | lemma | RepresentationTheory | [
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.GroupTheory.Abelianization.Defs",
"Mathlib.RepresentationTheory.Homological.GroupHomology.Basic",
"Mathlib.RepresentationTheory.Invariants"
] | Mathlib/RepresentationTheory/Homological/GroupHomology/LowDegree.lean | π_comp_H2Iso_inv | null |
noncomputable coinvariantsTensorResProjectiveResolutionIso
(P : ProjectiveResolution (Rep.trivial k G k)) :
((Action.res _ S.subtype).mapProjectiveResolution P).complex.coinvariantsTensorObj A ≅
P.complex.coinvariantsTensorObj (ind S.subtype A) :=
(NatIso.mapHomologicalComplex (coinvariantsTensorIndNatIso S.subtype A).symm _).app _ | abbrev | RepresentationTheory | [
"Mathlib.CategoryTheory.Preadditive.Projective.Resolution",
"Mathlib.RepresentationTheory.Homological.GroupHomology.Basic",
"Mathlib.RepresentationTheory.Coinduced",
"Mathlib.RepresentationTheory.Induced"
] | Mathlib/RepresentationTheory/Homological/GroupHomology/Shapiro.lean | coinvariantsTensorResProjectiveResolutionIso | Given a projective resolution `P` of `k` as a `k`-linear `G`-representation, a subgroup
`S ≤ G`, and a `k`-linear `S`-representation `A`, this is an isomorphism of complexes
`(A ⊗ Res(S)(P))_S ≅ (Ind_S^G(A) ⊗ P)_G`. |
noncomputable indIso [DecidableEq G] (A : Rep k S) (n : ℕ) :
groupHomology (ind S.subtype A) n ≅ groupHomology A n :=
(HomologicalComplex.homologyFunctor _ _ _).mapIso (inhomogeneousChainsIso (ind S.subtype A) ≪≫
(coinvariantsTensorResProjectiveResolutionIso S A (barResolution k G)).symm) ≪≫
(groupHomologyIso A n ((Action.res _ _).mapProjectiveResolution <| barResolution k G)).symm | def | RepresentationTheory | [
"Mathlib.CategoryTheory.Preadditive.Projective.Resolution",
"Mathlib.RepresentationTheory.Homological.GroupHomology.Basic",
"Mathlib.RepresentationTheory.Coinduced",
"Mathlib.RepresentationTheory.Induced"
] | Mathlib/RepresentationTheory/Homological/GroupHomology/Shapiro.lean | indIso | Shapiro's lemma: given a subgroup `S ≤ G` and an `S`-representation `A`, we have
`Hₙ(G, Ind_S^G(A)) ≅ Hₙ(S, A).` |
@[local simp]
transitionMap_ideal_mk {m n : ℕ} (hmn : m ≤ n) (x : R) :
transitionMap I R hmn (Ideal.Quotient.mk (I ^ n • ⊤ : Ideal R) x) =
Ideal.Quotient.mk (I ^ m • ⊤ : Ideal R) x :=
rfl
@[local simp] | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.AdicCompletion.Basic"
] | Mathlib/RingTheory/AdicCompletion/Algebra.lean | transitionMap_ideal_mk | null |
transitionMap_map_one {m n : ℕ} (hmn : m ≤ n) : transitionMap I R hmn 1 = 1 :=
rfl
@[local simp] | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.AdicCompletion.Basic"
] | Mathlib/RingTheory/AdicCompletion/Algebra.lean | transitionMap_map_one | null |
transitionMap_map_mul {m n : ℕ} (hmn : m ≤ n) (x y : R ⧸ (I ^ n • ⊤ : Ideal R)) :
transitionMap I R hmn (x * y) = transitionMap I R hmn x * transitionMap I R hmn y :=
Quotient.inductionOn₂' x y (fun _ _ ↦ rfl)
@[local simp] | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.AdicCompletion.Basic"
] | Mathlib/RingTheory/AdicCompletion/Algebra.lean | transitionMap_map_mul | null |
transitionMap_map_pow {m n a : ℕ} (hmn : m ≤ n) (x : R ⧸ (I ^ n • ⊤ : Ideal R)) :
transitionMap I R hmn (x ^ a) = transitionMap I R hmn x ^ a :=
Quotient.inductionOn' x (fun _ ↦ rfl) | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.AdicCompletion.Basic"
] | Mathlib/RingTheory/AdicCompletion/Algebra.lean | transitionMap_map_pow | null |
transitionMapₐ {m n : ℕ} (hmn : m ≤ n) :
R ⧸ (I ^ n • ⊤ : Ideal R) →ₐ[R] R ⧸ (I ^ m • ⊤ : Ideal R) :=
AlgHom.ofLinearMap (transitionMap I R hmn) rfl (transitionMap_map_mul I hmn) | def | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.AdicCompletion.Basic"
] | Mathlib/RingTheory/AdicCompletion/Algebra.lean | transitionMapₐ | `AdicCompletion.transitionMap` as an algebra homomorphism. |
subalgebra : Subalgebra R (∀ n, R ⧸ (I ^ n • ⊤ : Ideal R)) :=
Submodule.toSubalgebra (submodule I R) (fun _ ↦ by simp [transitionMap_map_one I])
(fun x y hx hy m n hmn ↦ by simp [hx hmn, hy hmn, transitionMap_map_mul I hmn]) | def | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.AdicCompletion.Basic"
] | Mathlib/RingTheory/AdicCompletion/Algebra.lean | subalgebra | `AdicCompletion I R` is an `R`-subalgebra of `∀ n, R ⧸ (I ^ n • ⊤ : Ideal R)`. |
subring : Subring (∀ n, R ⧸ (I ^ n • ⊤ : Ideal R)) :=
Subalgebra.toSubring (subalgebra I) | def | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.AdicCompletion.Basic"
] | Mathlib/RingTheory/AdicCompletion/Algebra.lean | subring | `AdicCompletion I R` is a subring of `∀ n, R ⧸ (I ^ n • ⊤ : Ideal R)`. |
@[simp]
val_one (n : ℕ) : (1 : AdicCompletion I R).val n = 1 :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.AdicCompletion.Basic"
] | Mathlib/RingTheory/AdicCompletion/Algebra.lean | val_one | null |
val_mul (n : ℕ) (x y : AdicCompletion I R) : (x * y).val n = x.val n * y.val n :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.AdicCompletion.Basic"
] | Mathlib/RingTheory/AdicCompletion/Algebra.lean | val_mul | null |
evalₐ (n : ℕ) : AdicCompletion I R →ₐ[R] R ⧸ I ^ n :=
have h : (I ^ n • ⊤ : Ideal R) = I ^ n := by ext x; simp
AlgHom.comp
(Ideal.quotientEquivAlgOfEq R h)
(AlgHom.ofLinearMap (eval I R n) rfl (fun _ _ ↦ rfl))
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.AdicCompletion.Basic"
] | Mathlib/RingTheory/AdicCompletion/Algebra.lean | evalₐ | The canonical algebra map from the adic completion to `R ⧸ I ^ n`.
This is `AdicCompletion.eval` postcomposed with the algebra isomorphism
`R ⧸ (I ^ n • ⊤) ≃ₐ[R] R ⧸ I ^ n`. |
evalₐ_mk (n : ℕ) (x : AdicCauchySequence I R) :
evalₐ I n (mk I R x) = Ideal.Quotient.mk (I ^ n) (x.val n) := by
simp [evalₐ] | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.AdicCompletion.Basic"
] | Mathlib/RingTheory/AdicCompletion/Algebra.lean | evalₐ_mk | null |
AdicCauchySequence.subalgebra : Subalgebra R (ℕ → R) :=
Submodule.toSubalgebra (AdicCauchySequence.submodule I R)
(fun {m n} _ ↦ by simp; rfl)
(fun x y hx hy {m n} hmn ↦ by
simp only [Pi.mul_apply]
exact SModEq.mul (hx hmn) (hy hmn)) | def | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.AdicCompletion.Basic"
] | Mathlib/RingTheory/AdicCompletion/Algebra.lean | AdicCauchySequence.subalgebra | `AdicCauchySequence I R` is an `R`-subalgebra of `ℕ → R`. |
AdicCauchySequence.subring : Subring (ℕ → R) :=
Subalgebra.toSubring (AdicCauchySequence.subalgebra I) | def | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.AdicCompletion.Basic"
] | Mathlib/RingTheory/AdicCompletion/Algebra.lean | AdicCauchySequence.subring | `AdicCauchySequence I R` is a subring of `ℕ → R`. |
@[simp]
one_apply (n : ℕ) : (1 : AdicCauchySequence I R) n = 1 :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.AdicCompletion.Basic"
] | Mathlib/RingTheory/AdicCompletion/Algebra.lean | one_apply | null |
mul_apply (n : ℕ) (f g : AdicCauchySequence I R) : (f * g) n = f n * g n :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.AdicCompletion.Basic"
] | Mathlib/RingTheory/AdicCompletion/Algebra.lean | mul_apply | null |
@[simps!]
mkₐ : AdicCauchySequence I R →ₐ[R] AdicCompletion I R :=
AlgHom.ofLinearMap (mk I R) rfl (fun _ _ ↦ rfl)
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.AdicCompletion.Basic"
] | Mathlib/RingTheory/AdicCompletion/Algebra.lean | mkₐ | The canonical algebra map from adic Cauchy sequences to the adic completion. |
evalₐ_mkₐ (n : ℕ) (x : AdicCauchySequence I R) :
evalₐ I n (mkₐ I x) = Ideal.Quotient.mk (I ^ n) (x.val n) := by
simp [mkₐ] | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.AdicCompletion.Basic"
] | Mathlib/RingTheory/AdicCompletion/Algebra.lean | evalₐ_mkₐ | null |
Ideal.mk_eq_mk {m n : ℕ} (hmn : m ≤ n) (r : AdicCauchySequence I R) :
Ideal.Quotient.mk (I ^ m) (r.val n) = Ideal.Quotient.mk (I ^ m) (r.val m) := by
have h : I ^ m = I ^ m • ⊤ := by simp
rw [← Ideal.Quotient.mk_eq_mk, ← Ideal.Quotient.mk_eq_mk, h]
exact (r.property hmn).symm | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.AdicCompletion.Basic"
] | Mathlib/RingTheory/AdicCompletion/Algebra.lean | Ideal.mk_eq_mk | null |
smul_mk {m n : ℕ} (hmn : m ≤ n) (r : AdicCauchySequence I R)
(x : AdicCauchySequence I M) :
r.val n • Submodule.Quotient.mk (p := (I ^ m • ⊤ : Submodule R M)) (x.val n) =
r.val m • Submodule.Quotient.mk (p := (I ^ m • ⊤ : Submodule R M)) (x.val m) := by
rw [← Submodule.Quotient.mk_smul, ← Module.Quotient.mk_smul_mk,
AdicCauchySequence.mk_eq_mk hmn, Ideal.mk_eq_mk I hmn, Module.Quotient.mk_smul_mk,
Submodule.Quotient.mk_smul] | theorem | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.AdicCompletion.Basic"
] | Mathlib/RingTheory/AdicCompletion/Algebra.lean | smul_mk | null |
module : Module (AdicCompletion I R) (AdicCompletion I M) where
one_smul b := by
ext n
simp only [smul_eval, val_one, one_smul]
mul_smul r s x := by
ext n
simp only [smul_eval, val_mul, mul_smul]
smul_zero r := by ext n; simp
smul_add r x y := by ext n; simp
add_smul r s x := by ext n; simp [add_smul]
zero_smul x := by ext n; simp | instance | RingTheory | [
"Mathlib.Algebra.Module.Torsion",
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.RingTheory.AdicCompletion.Basic"
] | Mathlib/RingTheory/AdicCompletion/Algebra.lean | module | Scalar multiplication of `R ⧸ (I • ⊤)` on `M ⧸ (I • ⊤)`. This is used in order to have
good definitional behaviour for the module instance on adic completions -/
instance : SMul (R ⧸ (I • ⊤ : Ideal R)) (M ⧸ (I • ⊤ : Submodule R M)) where
smul r x :=
Quotient.liftOn r (· • x) fun b₁ b₂ h ↦ by
refine Quotient.inductionOn' x (fun x ↦ ?_)
have h : b₁ - b₂ ∈ (I : Submodule R R) := by
rwa [show I = I • ⊤ by simp, ← Submodule.quotientRel_def]
rw [← sub_eq_zero, ← sub_smul, Submodule.Quotient.mk''_eq_mk,
← Submodule.Quotient.mk_smul, Submodule.Quotient.mk_eq_zero]
exact Submodule.smul_mem_smul h mem_top
@[local simp]
theorem mk_smul_mk (r : R) (x : M) :
Ideal.Quotient.mk (I • ⊤) r • Submodule.Quotient.mk (p := (I • ⊤ : Submodule R M)) x
= r • Submodule.Quotient.mk (p := (I • ⊤ : Submodule R M)) x :=
rfl
theorem val_smul_eq_evalₐ_smul (n : ℕ) (r : AdicCompletion I R)
(x : M ⧸ (I ^ n • ⊤ : Submodule R M)) : r.val n • x = evalₐ I n r • x := by
apply induction_on I R r (fun r ↦ ?_)
exact Quotient.inductionOn' x (fun x ↦ rfl)
instance : Module (R ⧸ (I • ⊤ : Ideal R)) (M ⧸ (I • ⊤ : Submodule R M)) :=
Function.Surjective.moduleLeft (Ideal.Quotient.mk (I • ⊤ : Ideal R))
Ideal.Quotient.mk_surjective (fun _ _ ↦ rfl)
instance : IsScalarTower R (R ⧸ (I • ⊤ : Ideal R)) (M ⧸ (I • ⊤ : Submodule R M)) where
smul_assoc r s x := by
refine Quotient.inductionOn' s (fun s ↦ ?_)
refine Quotient.inductionOn' x (fun x ↦ ?_)
simp only [Submodule.Quotient.mk''_eq_mk]
rw [← Submodule.Quotient.mk_smul, Ideal.Quotient.mk_eq_mk, mk_smul_mk, smul_assoc]
rfl
instance smul : SMul (AdicCompletion I R) (AdicCompletion I M) where
smul r x := {
val := fun n ↦ eval I R n r • eval I M n x
property := fun {m n} hmn ↦ by
apply induction_on I R r (fun r ↦ ?_)
apply induction_on I M x (fun x ↦ ?_)
simp only [coe_eval, mapQ_eq_factor, mk_apply_coe, mkQ_apply, Ideal.Quotient.mk_eq_mk,
mk_smul_mk, map_smul, mapQ_apply, LinearMap.id_coe, id_eq]
rw [smul_mk I hmn]
}
@[simp]
theorem smul_eval (n : ℕ) (r : AdicCompletion I R) (x : AdicCompletion I M) :
(r • x).val n = r.val n • x.val n :=
rfl
/-- `AdicCompletion I M` is naturally an `AdicCompletion I R` module. |
private
ofTensorProductBil : AdicCompletion I R →ₗ[AdicCompletion I R] M →ₗ[R] AdicCompletion I M where
toFun r := LinearMap.lsmul (AdicCompletion I R) (AdicCompletion I M) r ∘ₗ of I M
map_add' x y := by
apply LinearMap.ext
simp
map_smul' r x := by
apply LinearMap.ext
intro y
ext n
simp [mul_smul (r.val n)]
@[simp] | def | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | ofTensorProductBil | null |
private ofTensorProductBil_apply_apply (r : AdicCompletion I R) (x : M) :
((AdicCompletion.ofTensorProductBil I M) r) x = r • (of I M) x :=
rfl | lemma | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | ofTensorProductBil_apply_apply | null |
ofTensorProduct : AdicCompletion I R ⊗[R] M →ₗ[AdicCompletion I R] AdicCompletion I M :=
TensorProduct.AlgebraTensorModule.lift (ofTensorProductBil I M)
@[simp] | def | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | ofTensorProduct | The natural `AdicCompletion I R`-linear map from `AdicCompletion I R ⊗[R] M` to
the adic completion of `M`. |
ofTensorProduct_tmul (r : AdicCompletion I R) (x : M) :
ofTensorProduct I M (r ⊗ₜ x) = r • of I M x := by
simp [ofTensorProduct]
variable {M} in | lemma | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | ofTensorProduct_tmul | null |
ofTensorProduct_naturality (f : M →ₗ[R] N) :
map I f ∘ₗ ofTensorProduct I M =
ofTensorProduct I N ∘ₗ AlgebraTensorModule.map LinearMap.id f := by
ext
simp | lemma | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | ofTensorProduct_naturality | `ofTensorProduct` is functorial in `M`. |
private piEquivOfFintype_comp_ofTensorProduct_eq :
piEquivOfFintype I (fun _ : ι ↦ R) ∘ₗ ofTensorProduct I (ι → R) =
(TensorProduct.piScalarRight R (AdicCompletion I R) (AdicCompletion I R) ι).toLinearMap := by
ext i j k
suffices h : (if j = i then 1 else 0) = (if j = i then 1 else 0 : AdicCompletion I R).val k by
simpa [Pi.single_apply, -smul_eq_mul, -Algebra.id.smul_eq_mul]
split <;> simp | lemma | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | piEquivOfFintype_comp_ofTensorProduct_eq | null |
private ofTensorProduct_eq :
ofTensorProduct I (ι → R) = (piEquivOfFintype I (ι := ι) (fun _ : ι ↦ R)).symm.toLinearMap ∘ₗ
(TensorProduct.piScalarRight R (AdicCompletion I R) (AdicCompletion I R) ι).toLinearMap := by
rw [← piEquivOfFintype_comp_ofTensorProduct_eq I ι, ← LinearMap.comp_assoc]
simp
/- If `M = R^ι` and `ι` is finite, we may construct an inverse to `ofTensorProduct I (ι → R)`. -/ | lemma | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | ofTensorProduct_eq | null |
private ofTensorProductInvOfPiFintype :
AdicCompletion I (ι → R) ≃ₗ[AdicCompletion I R] AdicCompletion I R ⊗[R] (ι → R) :=
letI f := piEquivOfFintype I (fun _ : ι ↦ R)
letI g := (TensorProduct.piScalarRight R (AdicCompletion I R) (AdicCompletion I R) ι).symm
f.trans g | def | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | ofTensorProductInvOfPiFintype | null |
private ofTensorProductInvOfPiFintype_comp_ofTensorProduct :
ofTensorProductInvOfPiFintype I ι ∘ₗ ofTensorProduct I (ι → R) = LinearMap.id := by
dsimp only [ofTensorProductInvOfPiFintype]
rw [LinearEquiv.coe_trans, LinearMap.comp_assoc, piEquivOfFintype_comp_ofTensorProduct_eq]
simp | lemma | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | ofTensorProductInvOfPiFintype_comp_ofTensorProduct | null |
private ofTensorProduct_comp_ofTensorProductInvOfPiFintype :
ofTensorProduct I (ι → R) ∘ₗ ofTensorProductInvOfPiFintype I ι = LinearMap.id := by
dsimp only [ofTensorProductInvOfPiFintype]
rw [LinearEquiv.coe_trans, ofTensorProduct_eq, LinearMap.comp_assoc]
nth_rw 2 [← LinearMap.comp_assoc]
simp | lemma | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | ofTensorProduct_comp_ofTensorProductInvOfPiFintype | null |
ofTensorProductEquivOfPiFintype :
AdicCompletion I R ⊗[R] (ι → R) ≃ₗ[AdicCompletion I R] AdicCompletion I (ι → R) :=
LinearEquiv.ofLinear
(ofTensorProduct I (ι → R))
(ofTensorProductInvOfPiFintype I ι)
(ofTensorProduct_comp_ofTensorProductInvOfPiFintype I ι)
(ofTensorProductInvOfPiFintype_comp_ofTensorProduct I ι) | def | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | ofTensorProductEquivOfPiFintype | `ofTensorProduct` as an equiv in the case of `M = R^ι` where `ι` is finite. |
ofTensorProduct_bijective_of_pi_of_fintype [Finite ι] :
Function.Bijective (ofTensorProduct I (ι → R)) := by
classical
cases nonempty_fintype ι
exact EquivLike.bijective (ofTensorProductEquivOfPiFintype I ι) | lemma | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | ofTensorProduct_bijective_of_pi_of_fintype | If `M = R^ι`, `ofTensorProduct` is bijective. |
ofTensorProduct_surjective_of_finite [Module.Finite R M] :
Function.Surjective (ofTensorProduct I M) := by
obtain ⟨n, p, hp⟩ := Module.Finite.exists_fin' R M
let f := ofTensorProduct I M ∘ₗ p.baseChange (AdicCompletion I R)
let g := map I p ∘ₗ ofTensorProduct I (Fin n → R)
have hfg : f = g := by
ext
simp [f, g]
have hf : Function.Surjective f := by
simp only [hfg, LinearMap.coe_comp, g]
apply Function.Surjective.comp
· exact AdicCompletion.map_surjective I hp
· exact (ofTensorProduct_bijective_of_pi_of_fintype I (Fin n)).surjective
exact Function.Surjective.of_comp hf | lemma | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | ofTensorProduct_surjective_of_finite | If `M` is a finite `R`-module, then the canonical map
`AdicCompletion I R ⊗[R] M →ₗ AdicCompletion I M` is surjective. |
private
lTensorKerIncl : AdicCompletion I R ⊗[R] LinearMap.ker f →ₗ[AdicCompletion I R]
AdicCompletion I R ⊗[R] (ι → R) :=
AlgebraTensorModule.map LinearMap.id (LinearMap.ker f).subtype
/- The second horizontal arrow in the top row. -/ | def | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | lTensorKerIncl | null |
private lTensorf :
AdicCompletion I R ⊗[R] (ι → R) →ₗ[AdicCompletion I R] AdicCompletion I R ⊗[R] M :=
AlgebraTensorModule.map LinearMap.id f
variable (hf : Function.Surjective f)
include hf | def | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | lTensorf | null |
private tens_exact : Function.Exact (lTensorKerIncl I M f) (lTensorf I M f) :=
lTensor_exact (AdicCompletion I R) (f.exact_subtype_ker_map) hf | lemma | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | tens_exact | null |
private tens_surj : Function.Surjective (lTensorf I M f) :=
LinearMap.lTensor_surjective (AdicCompletion I R) hf | lemma | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | tens_surj | null |
private adic_exact [IsNoetherianRing R] [Fintype ι] :
Function.Exact (map I (LinearMap.ker f).subtype) (map I f) :=
map_exact (Submodule.injective_subtype _) (f.exact_subtype_ker_map) hf | lemma | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | adic_exact | null |
private adic_surj : Function.Surjective (map I f) :=
map_surjective I hf | lemma | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | adic_surj | null |
private
ofTensorProduct_bijective_of_map_from_fin [Fintype ι] [IsNoetherianRing R] :
Function.Bijective (ofTensorProduct I M) :=
LinearMap.bijective_of_surjective_of_bijective_of_bijective_of_injective
(lTensorKerIncl I M f)
(lTensorf I M f)
(0 : AdicCompletion I R ⊗[R] M →ₗ[AdicCompletion I R] Unit)
(0 : _ →ₗ[AdicCompletion I R] Unit)
(map I <| (LinearMap.ker f).subtype)
(map I f)
(0 : _ →ₗ[AdicCompletion I R] Unit)
(0 : _ →ₗ[AdicCompletion I R] Unit)
(ofTensorProduct I (LinearMap.ker f))
(ofTensorProduct I (ι → R))
(ofTensorProduct I M)
0
0
(ofTensorProduct_naturality I <| (LinearMap.ker f).subtype)
(ofTensorProduct_naturality I f)
rfl
rfl
(tens_exact I M f hf)
((LinearMap.exact_zero_iff_surjective _ _).mpr <| tens_surj I M f hf)
((LinearMap.exact_zero_iff_surjective _ _).mpr <| Function.surjective_to_subsingleton _)
(adic_exact I M f hf)
((LinearMap.exact_zero_iff_surjective _ _).mpr <| adic_surj I M f hf)
((LinearMap.exact_zero_iff_surjective _ _).mpr <| Function.surjective_to_subsingleton _)
(ofTensorProduct_surjective_of_finite I (LinearMap.ker f))
(ofTensorProduct_bijective_of_pi_of_fintype I ι)
(Function.bijective_of_subsingleton _)
(Function.injective_of_subsingleton _) | lemma | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | ofTensorProduct_bijective_of_map_from_fin | null |
ofTensorProduct_bijective_of_finite_of_isNoetherian
[Module.Finite R M] :
Function.Bijective (ofTensorProduct I M) := by
obtain ⟨n, f, hf⟩ := Module.Finite.exists_fin' R M
exact ofTensorProduct_bijective_of_map_from_fin I M f hf | theorem | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | ofTensorProduct_bijective_of_finite_of_isNoetherian | If `R` is a Noetherian ring and `M` is a finite `R`-module, then the natural map
given by `AdicCompletion.ofTensorProduct` is an isomorphism. |
ofTensorProductEquivOfFiniteNoetherian [Module.Finite R M] :
AdicCompletion I R ⊗[R] M ≃ₗ[AdicCompletion I R] AdicCompletion I M :=
LinearEquiv.ofBijective (ofTensorProduct I M)
(ofTensorProduct_bijective_of_finite_of_isNoetherian I M) | def | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | ofTensorProductEquivOfFiniteNoetherian | `ofTensorProduct` packaged as linear equiv if `M` is a finite `R`-module and `R` is
Noetherian. |
coe_ofTensorProductEquivOfFiniteNoetherian [Module.Finite R M] :
ofTensorProductEquivOfFiniteNoetherian I M = ofTensorProduct I M :=
rfl
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | coe_ofTensorProductEquivOfFiniteNoetherian | null |
ofTensorProductEquivOfFiniteNoetherian_apply [Module.Finite R M]
(x : AdicCompletion I R ⊗[R] M) :
ofTensorProductEquivOfFiniteNoetherian I M x = ofTensorProduct I M x :=
rfl
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | ofTensorProductEquivOfFiniteNoetherian_apply | null |
ofTensorProductEquivOfFiniteNoetherian_symm_of
[Module.Finite R M] (x : M) :
(ofTensorProductEquivOfFiniteNoetherian I M).symm ((of I M) x) = 1 ⊗ₜ x := by
have h : (of I M) x = ofTensorProductEquivOfFiniteNoetherian I M (1 ⊗ₜ x) := by
simp
rw [h, LinearEquiv.symm_apply_apply] | lemma | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | ofTensorProductEquivOfFiniteNoetherian_symm_of | null |
tensor_map_id_left_eq_map :
(AlgebraTensorModule.map LinearMap.id f) =
(ofTensorProductEquivOfFiniteNoetherian I N).symm.toLinearMap ∘ₗ
map I f ∘ₗ
(ofTensorProductEquivOfFiniteNoetherian I M).toLinearMap := by
rw [coe_ofTensorProductEquivOfFiniteNoetherian, ofTensorProduct_naturality I f]
ext x
simp
variable {f} | lemma | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | tensor_map_id_left_eq_map | null |
tensor_map_id_left_injective_of_injective (hf : Function.Injective f) :
Function.Injective (AlgebraTensorModule.map LinearMap.id f :
AdicCompletion I R ⊗[R] M →ₗ[AdicCompletion I R] AdicCompletion I R ⊗[R] N) := by
rw [tensor_map_id_left_eq_map I f]
simp only [LinearMap.coe_comp, LinearEquiv.coe_coe, EmbeddingLike.comp_injective,
EquivLike.injective_comp]
exact map_injective I hf | lemma | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | tensor_map_id_left_injective_of_injective | null |
flat_of_isNoetherian [IsNoetherianRing R] : Module.Flat R (AdicCompletion I R) :=
Module.Flat.iff_lTensor_injective'.mpr fun J ↦
tensor_map_id_left_injective_of_injective I (Submodule.injective_subtype J) | instance | RingTheory | [
"Mathlib.Algebra.FiveLemma",
"Mathlib.LinearAlgebra.TensorProduct.Pi",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.AdicCompletion.Exactness",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean | flat_of_isNoetherian | Adic completion of a Noetherian ring `R` is flat over `R`. |
IsHausdorff : Prop where
haus' : ∀ x : M, (∀ n : ℕ, x ≡ 0 [SMOD (I ^ n • ⊤ : Submodule R M)]) → x = 0 | class | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | IsHausdorff | A module `M` is Hausdorff with respect to an ideal `I` if `⋂ I^n M = 0`. |
IsPrecomplete : Prop where
prec' : ∀ f : ℕ → M, (∀ {m n}, m ≤ n → f m ≡ f n [SMOD (I ^ m • ⊤ : Submodule R M)]) →
∃ L : M, ∀ n, f n ≡ L [SMOD (I ^ n • ⊤ : Submodule R M)] | class | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | IsPrecomplete | A module `M` is precomplete with respect to an ideal `I` if every Cauchy sequence converges. |
IsAdicComplete : Prop extends IsHausdorff I M, IsPrecomplete I M
variable {I M} | class | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | IsAdicComplete | A module `M` is `I`-adically complete if it is Hausdorff and precomplete. |
IsHausdorff.haus (_ : IsHausdorff I M) :
∀ x : M, (∀ n : ℕ, x ≡ 0 [SMOD (I ^ n • ⊤ : Submodule R M)]) → x = 0 :=
IsHausdorff.haus' | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | IsHausdorff.haus | null |
isHausdorff_iff :
IsHausdorff I M ↔ ∀ x : M, (∀ n : ℕ, x ≡ 0 [SMOD (I ^ n • ⊤ : Submodule R M)]) → x = 0 :=
⟨IsHausdorff.haus, fun h => ⟨h⟩⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | isHausdorff_iff | null |
IsHausdorff.eq_iff_smodEq [IsHausdorff I M] {x y : M} :
x = y ↔ ∀ n, x ≡ y [SMOD (I ^ n • ⊤ : Submodule R M)] := by
refine ⟨fun h _ ↦ h ▸ rfl, fun h ↦ ?_⟩
rw [← sub_eq_zero]
apply IsHausdorff.haus' (I := I) (x - y)
simpa [SModEq.sub_mem] using h | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | IsHausdorff.eq_iff_smodEq | null |
IsPrecomplete.prec (_ : IsPrecomplete I M) {f : ℕ → M} :
(∀ {m n}, m ≤ n → f m ≡ f n [SMOD (I ^ m • ⊤ : Submodule R M)]) →
∃ L : M, ∀ n, f n ≡ L [SMOD (I ^ n • ⊤ : Submodule R M)] :=
IsPrecomplete.prec' _ | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | IsPrecomplete.prec | null |
isPrecomplete_iff :
IsPrecomplete I M ↔
∀ f : ℕ → M,
(∀ {m n}, m ≤ n → f m ≡ f n [SMOD (I ^ m • ⊤ : Submodule R M)]) →
∃ L : M, ∀ n, f n ≡ L [SMOD (I ^ n • ⊤ : Submodule R M)] :=
⟨fun h => h.1, fun h => ⟨h⟩⟩
variable (I M) | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | isPrecomplete_iff | null |
Hausdorffification : Type _ :=
M ⧸ (⨅ n : ℕ, I ^ n • ⊤ : Submodule R M) | abbrev | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | Hausdorffification | The Hausdorffification of a module with respect to an ideal. |
AdicCompletion.transitionMap {m n : ℕ} (hmn : m ≤ n) := factorPow I M hmn | abbrev | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | AdicCompletion.transitionMap | The canonical linear map `M ⧸ (I ^ n • ⊤) →ₗ[R] M ⧸ (I ^ m • ⊤)` for `m ≤ n` used
to define `AdicCompletion`. |
AdicCompletion : Type _ :=
{ f : ∀ n : ℕ, M ⧸ (I ^ n • ⊤ : Submodule R M) //
∀ {m n} (hmn : m ≤ n), AdicCompletion.transitionMap I M hmn (f n) = f m } | def | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | AdicCompletion | The completion of a module with respect to an ideal.
This is Hausdorff but not necessarily complete: a classical sufficient condition for
completeness is that `M` be finitely generated [Stacks, 0G1Q]. |
bot : IsHausdorff (⊥ : Ideal R) M :=
⟨fun x hx => by simpa only [pow_one ⊥, bot_smul, SModEq.bot] using hx 1⟩
variable {M} in | instance | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | bot | null |
protected subsingleton (h : IsHausdorff (⊤ : Ideal R) M) : Subsingleton M :=
⟨fun x y => eq_of_sub_eq_zero <| h.haus (x - y) fun n => by
rw [Ideal.top_pow, top_smul]
exact SModEq.top⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | subsingleton | null |
iInf_pow_smul (h : IsHausdorff I M) : (⨅ n : ℕ, I ^ n • ⊤ : Submodule R M) = ⊥ :=
eq_bot_iff.2 fun x hx =>
(mem_bot _).2 <| h.haus x fun n => SModEq.zero.2 <| (mem_iInf fun n : ℕ => I ^ n • ⊤).1 hx n | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | iInf_pow_smul | null |
of : M →ₗ[R] Hausdorffification I M :=
mkQ _
variable {I M}
@[elab_as_elim] | def | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | of | The canonical linear map to the Hausdorffification. |
induction_on {C : Hausdorffification I M → Prop} (x : Hausdorffification I M)
(ih : ∀ x, C (of I M x)) : C x :=
Quotient.inductionOn' x ih
variable (I M) | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | induction_on | null |
lift (f : M →ₗ[R] N) : Hausdorffification I M →ₗ[R] N :=
liftQ _ f <| map_le_iff_le_comap.1 <| h.iInf_pow_smul ▸ le_iInf fun n =>
le_trans (map_mono <| iInf_le _ n) <| by
rw [map_smul'']
exact smul_mono le_rfl le_top | def | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | lift | Universal property of Hausdorffification: any linear map to a Hausdorff module extends to a
unique map from the Hausdorffification. |
lift_of (f : M →ₗ[R] N) (x : M) : lift I f (of I M x) = f x :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | lift_of | null |
lift_comp_of (f : M →ₗ[R] N) : (lift I f).comp (of I M) = f :=
LinearMap.ext fun _ => rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | lift_comp_of | null |
lift_eq (f : M →ₗ[R] N) (g : Hausdorffification I M →ₗ[R] N) (hg : g.comp (of I M) = f) :
g = lift I f :=
LinearMap.ext fun x => induction_on x fun x => by rw [lift_of, ← hg, LinearMap.comp_apply] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | lift_eq | Uniqueness of lift. |
bot : IsPrecomplete (⊥ : Ideal R) M := by
refine ⟨fun f hf => ⟨f 1, fun n => ?_⟩⟩
rcases n with - | n
· rw [pow_zero, Ideal.one_eq_top, top_smul]
exact SModEq.top
specialize hf (Nat.le_add_left 1 n)
rw [pow_one, bot_smul, SModEq.bot] at hf; rw [hf] | instance | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | bot | null |
top : IsPrecomplete (⊤ : Ideal R) M :=
⟨fun f _ =>
⟨0, fun n => by
rw [Ideal.top_pow, top_smul]
exact SModEq.top⟩⟩ | instance | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | top | null |
submodule : Submodule R (∀ n : ℕ, M ⧸ (I ^ n • ⊤ : Submodule R M)) where
carrier := { f | ∀ {m n} (hmn : m ≤ n), AdicCompletion.transitionMap I M hmn (f n) = f m }
zero_mem' hmn := by rw [Pi.zero_apply, Pi.zero_apply, LinearMap.map_zero]
add_mem' hf hg m n hmn := by
rw [Pi.add_apply, Pi.add_apply, LinearMap.map_add, hf hmn, hg hmn]
smul_mem' c f hf m n hmn := by rw [Pi.smul_apply, Pi.smul_apply, LinearMap.map_smul, hf hmn] | def | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | submodule | `AdicCompletion` is the submodule of compatible families in
`∀ n : ℕ, M ⧸ (I ^ n • ⊤)`. |
instSMul [SMul S R] [SMul S M] [IsScalarTower S R M] : SMul S (AdicCompletion I M) where
smul r x := ⟨r • x.val, by simp [x.property]⟩
@[simp, norm_cast] lemma val_zero : (0 : AdicCompletion I M).val = 0 := rfl | instance | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | instSMul | null |
val_zero_apply (n : ℕ) : (0 : AdicCompletion I M).val n = 0 := rfl
variable {I M}
@[simp, norm_cast] lemma val_add (f g : AdicCompletion I M) : (f + g).val = f.val + g.val := rfl
@[simp, norm_cast] lemma val_sub (f g : AdicCompletion I M) : (f - g).val = f.val - g.val := rfl
@[simp, norm_cast] lemma val_neg (f : AdicCompletion I M) : (-f).val = -f.val := rfl | lemma | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | val_zero_apply | null |
val_add_apply (f g : AdicCompletion I M) (n : ℕ) : (f + g).val n = f.val n + g.val n := rfl | lemma | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | val_add_apply | null |
val_sub_apply (f g : AdicCompletion I M) (n : ℕ) : (f - g).val n = f.val n - g.val n := rfl | lemma | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | val_sub_apply | null |
val_neg_apply (f : AdicCompletion I M) (n : ℕ) : (-f).val n = -f.val n := rfl
/- No `simp` attribute, since it causes `simp` unification timeouts when considering
the `Module (AdicCompletion I R) (AdicCompletion I M)` instance (see `AdicCompletion/Algebra`). -/
@[norm_cast] | lemma | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | val_neg_apply | null |
val_smul [SMul S R] [SMul S M] [IsScalarTower S R M] (s : S) (f : AdicCompletion I M) :
(s • f).val = s • f.val := rfl | lemma | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | val_smul | null |
val_smul_apply [SMul S R] [SMul S M] [IsScalarTower S R M] (s : S) (f : AdicCompletion I M)
(n : ℕ) : (s • f).val n = s • f.val n := rfl
@[ext] | lemma | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | val_smul_apply | null |
ext {x y : AdicCompletion I M} (h : ∀ n, x.val n = y.val n) : x = y := Subtype.eq <| funext h
variable (I M) | lemma | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | ext | null |
instIsScalarTower [SMul S T] [SMul S R] [SMul T R] [SMul S M] [SMul T M]
[IsScalarTower S R M] [IsScalarTower T R M] [IsScalarTower S T M] :
IsScalarTower S T (AdicCompletion I M) where
smul_assoc s t f := by ext; simp [val_smul] | instance | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | instIsScalarTower | null |
instSMulCommClass [SMul S R] [SMul T R] [SMul S M] [SMul T M]
[IsScalarTower S R M] [IsScalarTower T R M] [SMulCommClass S T M] :
SMulCommClass S T (AdicCompletion I M) where
smul_comm s t f := by ext; simp [val_smul, smul_comm] | instance | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | instSMulCommClass | null |
instIsCentralScalar [SMul S R] [SMul Sᵐᵒᵖ R] [SMul S M] [SMul Sᵐᵒᵖ M]
[IsScalarTower S R M] [IsScalarTower Sᵐᵒᵖ R M] [IsCentralScalar S M] :
IsCentralScalar S (AdicCompletion I M) where
op_smul_eq_smul s f := by ext; simp [val_smul, op_smul_eq_smul] | instance | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | instIsCentralScalar | null |
@[simps]
incl : AdicCompletion I M →ₗ[R] (∀ n, M ⧸ (I ^ n • ⊤ : Submodule R M)) where
toFun x := x.val
map_add' _ _ := rfl
map_smul' _ _ := rfl
variable {I M}
@[simp, norm_cast] | def | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | incl | The canonical inclusion from the completion to the product. |
val_sum {ι : Type*} (s : Finset ι) (f : ι → AdicCompletion I M) :
(∑ i ∈ s, f i).val = ∑ i ∈ s, (f i).val := by
simp_rw [← funext (incl_apply _ _ _), map_sum] | lemma | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | val_sum | null |
val_sum_apply {ι : Type*} (s : Finset ι) (f : ι → AdicCompletion I M) (n : ℕ) :
(∑ i ∈ s, f i).val n = ∑ i ∈ s, (f i).val n := by simp
variable (I M) | lemma | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | val_sum_apply | null |
of : M →ₗ[R] AdicCompletion I M where
toFun x := ⟨fun n => mkQ (I ^ n • ⊤ : Submodule R M) x, fun _ => rfl⟩
map_add' _ _ := rfl
map_smul' _ _ := rfl
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | of | The canonical linear map to the completion. |
of_apply (x : M) (n : ℕ) : (of I M x).1 n = mkQ (I ^ n • ⊤ : Submodule R M) x :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | of_apply | null |
eval (n : ℕ) : AdicCompletion I M →ₗ[R] M ⧸ (I ^ n • ⊤ : Submodule R M) where
toFun f := f.1 n
map_add' _ _ := rfl
map_smul' _ _ := rfl
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | eval | Linearly evaluating a sequence in the completion at a given input. |
coe_eval (n : ℕ) :
(eval I M n : AdicCompletion I M → M ⧸ (I ^ n • ⊤ : Submodule R M)) = fun f => f.1 n :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | coe_eval | null |
eval_apply (n : ℕ) (f : AdicCompletion I M) : eval I M n f = f.1 n :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | eval_apply | null |
eval_of (n : ℕ) (x : M) : eval I M n (of I M x) = mkQ (I ^ n • ⊤ : Submodule R M) x :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | eval_of | null |
eval_comp_of (n : ℕ) : (eval I M n).comp (of I M) = mkQ _ :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | eval_comp_of | null |
eval_surjective (n : ℕ) : Function.Surjective (eval I M n) := fun x ↦
Quotient.inductionOn' x fun x ↦ ⟨of I M x, rfl⟩
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | eval_surjective | null |
range_eval (n : ℕ) : LinearMap.range (eval I M n) = ⊤ :=
LinearMap.range_eq_top.2 (eval_surjective I M n)
variable {I M}
variable (I M) | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | range_eval | null |
@[simp]
transitionMap_comp_eval_apply {m n : ℕ} (hmn : m ≤ n) (x : AdicCompletion I M) :
transitionMap I M hmn (x.val n) = x.val m :=
x.property hmn
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | transitionMap_comp_eval_apply | null |
transitionMap_comp_eval {m n : ℕ} (hmn : m ≤ n) :
transitionMap I M hmn ∘ₗ eval I M n = eval I M m := by
ext x
simp | theorem | RingTheory | [
"Mathlib.Algebra.Ring.GeomSum",
"Mathlib.LinearAlgebra.SModEq",
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Ideal.Quotient.PowTransition"
] | Mathlib/RingTheory/AdicCompletion/Basic.lean | transitionMap_comp_eval | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.