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 ⌀ |
|---|---|---|---|---|---|---|
FiniteType.small [Small.{u} R] [Algebra.FiniteType R S] :
Small.{u} S := by
have : Small.{u} (⊤ : Subalgebra R S) :=
Subalgebra.FG.small Algebra.FiniteType.out
rwa [← small_univ_iff] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Finsupp.LinearCombination",
"Mathlib.RingTheory.FiniteType",
"Mathlib.LinearAlgebra.DFinsupp",
"Mathlib.Algebra.Algebra.Subalgebra.Basic",
"Mathlib.LinearAlgebra.Basis.Cardinality",
"Mathlib.LinearAlgebra.StdBasis",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.MvPo... | Mathlib/RingTheory/Finiteness/Small.lean | FiniteType.small | null |
fg_bot_toSubmodule : (⊥ : Subalgebra R A).toSubmodule.FG :=
⟨{1}, by simp [Algebra.toSubmodule_bot, one_eq_span]⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Finiteness.Bilinear"
] | Mathlib/RingTheory/Finiteness/Subalgebra.lean | fg_bot_toSubmodule | null |
finite_bot : Module.Finite R (⊥ : Subalgebra R A) :=
Module.Finite.range (Algebra.linearMap R A) | instance | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Finiteness.Bilinear"
] | Mathlib/RingTheory/Finiteness/Subalgebra.lean | finite_bot | null |
fg_unit {R A : Type*} [CommSemiring R] [Semiring A] [Algebra R A] (I : (Submodule R A)ˣ) :
(I : Submodule R A).FG := by
obtain ⟨T, T', hT, hT', one_mem⟩ := mem_span_mul_finite_of_mem_mul (I.mul_inv ▸ one_le.mp le_rfl)
refine ⟨T, span_eq_of_le _ hT ?_⟩
rw [← one_mul I, ← mul_one (span R (T : Set A))]
conv_rhs => rw [← I.inv_mul, ← mul_assoc]
refine mul_le_mul_right' (le_trans ?_ <| mul_le_mul_left' (span_le.mpr hT') _) _
rwa [Units.val_one, span_mul_span, one_le] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Finiteness.Bilinear"
] | Mathlib/RingTheory/Finiteness/Subalgebra.lean | fg_unit | null |
fg_of_isUnit {R A : Type*} [CommSemiring R] [Semiring A] [Algebra R A] {I : Submodule R A}
(hI : IsUnit I) : I.FG :=
fg_unit hI.unit | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Finiteness.Bilinear"
] | Mathlib/RingTheory/Finiteness/Subalgebra.lean | fg_of_isUnit | null |
FG.mul (hm : M.FG) (hn : N.FG) : (M * N).FG := by
rw [mul_eq_map₂]; exact hm.map₂ _ hn | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Finiteness.Bilinear"
] | Mathlib/RingTheory/Finiteness/Subalgebra.lean | FG.mul | null |
FG.pow (h : M.FG) (n : ℕ) : (M ^ n).FG :=
Nat.recOn n ⟨{1}, by simp [one_eq_span]⟩ fun n ih => by simpa [pow_succ] using ih.mul h | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Finiteness.Bilinear"
] | Mathlib/RingTheory/Finiteness/Subalgebra.lean | FG.pow | null |
_root_.LinearMap.rTensor_injective_of_fg {f : N →ₗ[R] P}
(h : ∀ (N' : Submodule R N) (P' : Submodule R P),
N'.FG → P'.FG → ∀ h : N' ≤ P'.comap f, Function.Injective ((f.restrict h).rTensor M)) :
Function.Injective (f.rTensor M) := fun x y eq ↦ by
have ⟨N', Nfg, sub⟩ := Submodule.exists_fg_le_subset_range_rTensor_subtype {x, y} (by simp)
obtain ⟨x, rfl⟩ := sub (.inl rfl)
obtain ⟨y, rfl⟩ := sub (.inr rfl)
simp_rw [← rTensor_comp_apply, show f ∘ₗ N'.subtype = (N'.map f).subtype ∘ₗ f.submoduleMap N'
from rfl, rTensor_comp_apply] at eq
have ⟨P', Pfg, le, eq⟩ := (Nfg.map _).exists_rTensor_fg_inclusion_eq eq
simp_rw [← rTensor_comp_apply] at eq
rw [h _ _ Nfg Pfg (map_le_iff_le_comap.mp le) eq] | theorem | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | _root_.LinearMap.rTensor_injective_of_fg | null |
_root_.LinearMap.rTensor_injective_iff_subtype {f : N →ₗ[R] P} (hf : Function.Injective f)
(e : P ≃ₗ[R] Q) : Function.Injective (f.rTensor M) ↔
Function.Injective ((range <| e.toLinearMap ∘ₗ f).subtype.rTensor M) := by
simp_rw [← EquivLike.injective_comp <| (LinearEquiv.ofInjective (e.toLinearMap ∘ₗ f)
(e.injective.comp hf)).rTensor M, ← EquivLike.comp_injective _ (e.rTensor M),
← LinearEquiv.coe_coe, ← coe_comp, LinearEquiv.coe_rTensor, ← rTensor_comp]
rfl
variable (R M) in | lemma | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | _root_.LinearMap.rTensor_injective_iff_subtype | null |
@[mk_iff] Flat : Prop where
out ⦃P : Type u⦄ [AddCommMonoid P] [Module R P] [Module.Finite R P] (N : Submodule R P) : N.FG →
Function.Injective (N.subtype.rTensor M) | class | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | Flat | An `R`-module `M` is flat if for every finitely generated submodule `N` of every
finitely generated `R`-module `P` in the same universe as `R`,
the canonical map `N ⊗ M → P ⊗ M` is injective. This implies the same is true for
arbitrary `R`-modules `N` and `P` and injective linear maps `N →ₗ[R] P`, see
`Flat.rTensor_preserves_injective_linearMap`. To show a module over a ring `R` is flat, it
suffices to consider the case `P = R`, see `Flat.iff_rTensor_injective`. |
rTensor_preserves_injective_linearMap [Flat R M] (f : N →ₗ[R] P)
(hf : Function.Injective f) : Function.Injective (f.rTensor M) := by
refine rTensor_injective_of_fg fun N P Nfg Pfg le ↦ ?_
rw [← Finite.iff_fg] at Nfg Pfg
have := Finite.small R P
let se := (Shrink.linearEquiv R P).symm
have := Module.Finite.equiv se
rw [rTensor_injective_iff_subtype (fun _ _ ↦ (Subtype.ext <| hf <| Subtype.ext_iff.mp ·)) se]
exact (flat_iff R M).mp ‹_› _ (Finite.iff_fg.mp inferInstance) | theorem | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | rTensor_preserves_injective_linearMap | If `M` is a flat module, then `f ⊗ 𝟙 M` is injective for all injective linear maps `f`. |
lTensor_preserves_injective_linearMap [Flat R M] (f : N →ₗ[R] P)
(hf : Function.Injective f) : Function.Injective (f.lTensor M) :=
(f.lTensor_inj_iff_rTensor_inj M).2 (rTensor_preserves_injective_linearMap f hf) | theorem | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | lTensor_preserves_injective_linearMap | If `M` is a flat module, then `𝟙 M ⊗ f` is injective for all injective linear maps `f`. |
iff_rTensor_preserves_injective_linearMapₛ [Small.{v'} R] : Flat R M ↔
∀ ⦃N N' : Type v'⦄ [AddCommMonoid N] [AddCommMonoid N'] [Module R N] [Module R N']
(f : N →ₗ[R] N'), Function.Injective f → Function.Injective (f.rTensor M) :=
⟨by introv _; apply rTensor_preserves_injective_linearMap, fun h ↦ ⟨fun P _ _ _ _ _ ↦ by
have := Finite.small.{v'} R P
rw [rTensor_injective_iff_subtype Subtype.val_injective (Shrink.linearEquiv R P).symm]
exact h _ Subtype.val_injective⟩⟩ | lemma | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | iff_rTensor_preserves_injective_linearMapₛ | `M` is flat if and only if `f ⊗ 𝟙 M` is injective whenever `f` is an injective linear map
in a universe that `R` fits in. |
iff_lTensor_preserves_injective_linearMapₛ [Small.{v'} R] : Flat R M ↔
∀ ⦃N N' : Type v'⦄ [AddCommMonoid N] [AddCommMonoid N'] [Module R N] [Module R N']
(f : N →ₗ[R] N'), Function.Injective f → Function.Injective (f.lTensor M) := by
simp_rw [iff_rTensor_preserves_injective_linearMapₛ, LinearMap.lTensor_inj_iff_rTensor_inj] | lemma | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | iff_lTensor_preserves_injective_linearMapₛ | `M` is flat if and only if `𝟙 M ⊗ f` is injective whenever `f` is an injective linear map
in a universe that `R` fits in. |
iff_rTensor_injectiveₛ : Flat R M ↔ ∀ ⦃P : Type u⦄ [AddCommMonoid P] [Module R P]
(N : Submodule R P), Function.Injective (N.subtype.rTensor M) :=
⟨fun _ _ _ _ _ ↦ rTensor_preserves_injective_linearMap _ Subtype.val_injective,
fun h ↦ ⟨fun _ _ _ _ _ _ ↦ h _⟩⟩ | lemma | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | iff_rTensor_injectiveₛ | An easier-to-use version of `Module.flat_iff`, with finiteness conditions removed. |
iff_lTensor_injectiveₛ : Flat R M ↔ ∀ ⦃P : Type u⦄ [AddCommMonoid P] [Module R P]
(N : Submodule R P), Function.Injective (N.subtype.lTensor M) := by
simp_rw [iff_rTensor_injectiveₛ, LinearMap.lTensor_inj_iff_rTensor_inj] | lemma | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | iff_lTensor_injectiveₛ | null |
instSubalgebraToSubmodule {S : Type v} [Semiring S] [Algebra R S]
(A : Subalgebra R S) [Flat R A] : Flat R A.toSubmodule := ‹Flat R A› | instance | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | instSubalgebraToSubmodule | null |
self : Flat R R where
out _ _ _ _ I _ := by
rw [← (TensorProduct.rid R I).symm.injective_comp, ← (TensorProduct.rid R _).comp_injective]
convert Subtype.coe_injective using 1
ext; simp | instance | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | self | null |
of_retract [f : Flat R M] (i : N →ₗ[R] M) (r : M →ₗ[R] N) (h : r.comp i = LinearMap.id) :
Flat R N := by
rw [iff_rTensor_injectiveₛ] at *
refine fun P _ _ Q ↦ .of_comp (f := lTensor P i) ?_
rw [← coe_comp, lTensor_comp_rTensor, ← rTensor_comp_lTensor, coe_comp]
refine (f Q).comp (Function.RightInverse.injective (g := lTensor Q r) fun x ↦ ?_)
simp [← comp_apply, ← lTensor_comp, h] | lemma | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | of_retract | A retract of a flat `R`-module is flat. |
of_linearEquiv [Flat R M] (e : N ≃ₗ[R] M) : Flat R N :=
of_retract e.toLinearMap e.symm (by simp) | lemma | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | of_linearEquiv | A `R`-module linearly equivalent to a flat `R`-module is flat. |
equiv_iff (e : M ≃ₗ[R] N) : Flat R M ↔ Flat R N :=
⟨fun _ ↦ of_linearEquiv e.symm, fun _ ↦ of_linearEquiv e⟩ | lemma | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | equiv_iff | If an `R`-module `M` is linearly equivalent to another `R`-module `N`, then `M` is flat
if and only if `N` is flat. |
ulift [Flat R M] : Flat R (ULift.{v'} M) :=
of_linearEquiv ULift.moduleEquiv | instance | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | ulift | null |
of_ulift [Flat R (ULift.{v'} M)] : Flat R M :=
of_linearEquiv ULift.moduleEquiv.symm | lemma | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | of_ulift | null |
shrink [Small.{v'} M] [Flat R M] : Flat R (Shrink.{v'} M) :=
of_linearEquiv (Shrink.linearEquiv R M) | instance | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | shrink | null |
of_shrink [Small.{v'} M] [Flat R (Shrink.{v'} M)] : Flat R M :=
of_linearEquiv (Shrink.linearEquiv R M).symm | lemma | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | of_shrink | null |
directSum_iff : Flat R (⨁ i, M i) ↔ ∀ i, Flat R (M i) := by
classical
simp_rw [iff_rTensor_injectiveₛ, ← EquivLike.comp_injective _ (directSumRight R _ _),
← LinearEquiv.coe_coe, ← coe_comp, directSumRight_comp_rTensor, coe_comp, LinearEquiv.coe_coe,
EquivLike.injective_comp, lmap_injective]
constructor <;> (intro h; intros; apply h) | theorem | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | directSum_iff | null |
dfinsupp_iff : Flat R (Π₀ i, M i) ↔ ∀ i, Flat R (M i) := directSum_iff .. | theorem | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | dfinsupp_iff | null |
directSum [∀ i, Flat R (M i)] : Flat R (⨁ i, M i) := directSum_iff.mpr ‹_› | instance | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | directSum | A direct sum of flat `R`-modules is flat. |
dfinsupp [∀ i, Flat R (M i)] : Flat R (Π₀ i, M i) := dfinsupp_iff.mpr ‹_› | instance | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | dfinsupp | null |
finsupp (ι : Type v) : Flat R (ι →₀ R) := by
classical exact of_linearEquiv (finsuppLEquivDirectSum R R ι) | instance | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | finsupp | Free `R`-modules over discrete types are flat. |
of_projective [Projective R M] : Flat R M :=
have ⟨e, he⟩:= Module.projective_def'.mp ‹_›
of_retract _ _ he | instance | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | of_projective | null |
of_free [Free R M] : Flat R M := inferInstance | instance | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | of_free | null |
linearIndependent_one_tmul {S} [Semiring S] [Algebra R S] [Flat R S] {ι} {v : ι → M}
(hv : LinearIndependent R v) : LinearIndependent S ((1 : S) ⊗ₜ[R] v ·) := by
classical rw [LinearIndependent, ← LinearMap.coe_restrictScalars R,
Finsupp.linearCombination_one_tmul]
simpa using lTensor_preserves_injective_linearMap _ hv | theorem | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | linearIndependent_one_tmul | null |
iff_rTensor_preserves_injective_linearMap' [Small.{v'} R] : Flat R M ↔
∀ ⦃N N' : Type v'⦄ [AddCommGroup N] [AddCommGroup N'] [Module R N] [Module R N']
(f : N →ₗ[R] N'), Function.Injective f → Function.Injective (f.rTensor M) :=
⟨by introv _; apply rTensor_preserves_injective_linearMap, fun h ↦
iff_rTensor_preserves_injective_linearMapₛ.mpr fun P N _ _ _ _ ↦ by
letI := Module.addCommMonoidToAddCommGroup R (M := P)
letI := Module.addCommMonoidToAddCommGroup R (M := N)
apply h⟩ | lemma | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | iff_rTensor_preserves_injective_linearMap' | `M` is flat if and only if `f ⊗ 𝟙 M` is injective whenever `f` is an injective linear map.
See `Module.Flat.iff_rTensor_preserves_injective_linearMap` to specialize the universe of
`N, N', N''` to `Type (max u v)`. |
iff_rTensor_preserves_injective_linearMap : Flat R M ↔
∀ ⦃N N' : Type (max u v)⦄ [AddCommGroup N] [AddCommGroup N'] [Module R N] [Module R N']
(f : N →ₗ[R] N'), Function.Injective f → Function.Injective (f.rTensor M) :=
iff_rTensor_preserves_injective_linearMap' | lemma | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | iff_rTensor_preserves_injective_linearMap | `M` is flat if and only if `f ⊗ 𝟙 M` is injective whenever `f` is an injective linear map.
See `Module.Flat.iff_rTensor_preserves_injective_linearMap'` to generalize the universe of
`N, N', N''` to any universe that is higher than `R` and `M`. |
iff_lTensor_preserves_injective_linearMap' [Small.{v'} R] : Flat R M ↔
∀ ⦃N N' : Type v'⦄ [AddCommGroup N] [AddCommGroup N'] [Module R N] [Module R N']
(f : N →ₗ[R] N'), Function.Injective f → Function.Injective (f.lTensor M) := by
simp_rw [iff_rTensor_preserves_injective_linearMap', LinearMap.lTensor_inj_iff_rTensor_inj] | lemma | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | iff_lTensor_preserves_injective_linearMap' | `M` is flat if and only if `𝟙 M ⊗ f` is injective whenever `f` is an injective linear map.
See `Module.Flat.iff_lTensor_preserves_injective_linearMap` to specialize the universe of
`N, N', N''` to `Type (max u v)`. |
iff_lTensor_preserves_injective_linearMap : Flat R M ↔
∀ ⦃N N' : Type (max u v)⦄ [AddCommGroup N] [AddCommGroup N'] [Module R N] [Module R N']
(f : N →ₗ[R] N'), Function.Injective f → Function.Injective (f.lTensor M) :=
iff_lTensor_preserves_injective_linearMap'
variable (M) in | lemma | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | iff_lTensor_preserves_injective_linearMap | `M` is flat if and only if `𝟙 M ⊗ f` is injective whenever `f` is an injective linear map.
See `Module.Flat.iff_lTensor_preserves_injective_linearMap'` to generalize the universe of
`N, N', N''` to any universe that is higher than `R` and `M`. |
lTensor_exact [Flat R M] ⦃N N' N'' : Type*⦄
[AddCommGroup N] [AddCommGroup N'] [AddCommGroup N''] [Module R N] [Module R N'] [Module R N'']
⦃f : N →ₗ[R] N'⦄ ⦃g : N' →ₗ[R] N''⦄ (exact : Function.Exact f g) :
Function.Exact (f.lTensor M) (g.lTensor M) := by
let π : N' →ₗ[R] N' ⧸ LinearMap.range f := Submodule.mkQ _
let ι : N' ⧸ LinearMap.range f →ₗ[R] N'' :=
Submodule.subtype _ ∘ₗ (LinearMap.quotKerEquivRange g).toLinearMap ∘ₗ
Submodule.quotEquivOfEq (LinearMap.range f) (LinearMap.ker g)
(LinearMap.exact_iff.mp exact).symm
suffices exact1 : Function.Exact (f.lTensor M) (π.lTensor M) by
rw [show g = ι.comp π from rfl, lTensor_comp]
exact exact1.comp_injective _ (lTensor_preserves_injective_linearMap ι <| by
simpa [ι, - Subtype.val_injective] using Subtype.val_injective) (map_zero _)
exact _root_.lTensor_exact _ (fun x ↦ by simp [π]) Quotient.mk''_surjective
variable (M) in | lemma | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | lTensor_exact | If `M` is flat then `M ⊗ -` is an exact functor. |
rTensor_exact [Flat R M] ⦃N N' N'' : Type*⦄
[AddCommGroup N] [AddCommGroup N'] [AddCommGroup N''] [Module R N] [Module R N'] [Module R N'']
⦃f : N →ₗ[R] N'⦄ ⦃g : N' →ₗ[R] N''⦄ (exact : Function.Exact f g) :
Function.Exact (f.rTensor M) (g.rTensor M) := by
let π : N' →ₗ[R] N' ⧸ LinearMap.range f := Submodule.mkQ _
let ι : N' ⧸ LinearMap.range f →ₗ[R] N'' :=
Submodule.subtype _ ∘ₗ (LinearMap.quotKerEquivRange g).toLinearMap ∘ₗ
Submodule.quotEquivOfEq (LinearMap.range f) (LinearMap.ker g)
(LinearMap.exact_iff.mp exact).symm
suffices exact1 : Function.Exact (f.rTensor M) (π.rTensor M) by
rw [show g = ι.comp π from rfl, rTensor_comp]
exact exact1.comp_injective _ (rTensor_preserves_injective_linearMap ι <| by
simpa [ι, - Subtype.val_injective] using Subtype.val_injective) (map_zero _)
exact _root_.rTensor_exact M (fun x ↦ by simp [π]) Quotient.mk''_surjective | lemma | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | rTensor_exact | If `M` is flat then `- ⊗ M` is an exact functor. |
iff_lTensor_exact' [Small.{v'} R] : Flat R M ↔
∀ ⦃N N' N'' : Type v'⦄ [AddCommGroup N] [AddCommGroup N'] [AddCommGroup N'']
[Module R N] [Module R N'] [Module R N''] ⦃f : N →ₗ[R] N'⦄ ⦃g : N' →ₗ[R] N''⦄,
Function.Exact f g → Function.Exact (f.lTensor M) (g.lTensor M) := by
refine ⟨fun _ ↦ lTensor_exact _, fun H ↦ iff_lTensor_preserves_injective_linearMap'.mpr
fun N' N'' _ _ _ _ L hL ↦ LinearMap.ker_eq_bot |>.mp <| eq_bot_iff |>.mpr
fun x (hx : _ = 0) ↦ ?_⟩
simpa [Eq.comm] using @H PUnit N' N'' _ _ _ _ _ _ 0 L (fun x ↦ by
simp_rw [Set.mem_range, LinearMap.zero_apply, exists_const]
exact (L.map_eq_zero_iff hL).trans eq_comm) x |>.mp hx | theorem | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | iff_lTensor_exact' | `M` is flat if and only if `M ⊗ -` is an exact functor. See
`Module.Flat.iff_lTensor_exact` to specialize the universe of `N, N', N''` to `Type (max u v)`. |
iff_lTensor_exact : Flat R M ↔
∀ ⦃N N' N'' : Type (max u v)⦄ [AddCommGroup N] [AddCommGroup N'] [AddCommGroup N'']
[Module R N] [Module R N'] [Module R N''] ⦃f : N →ₗ[R] N'⦄ ⦃g : N' →ₗ[R] N''⦄,
Function.Exact f g → Function.Exact (f.lTensor M) (g.lTensor M) :=
iff_lTensor_exact' | theorem | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | iff_lTensor_exact | `M` is flat if and only if `M ⊗ -` is an exact functor.
See `Module.Flat.iff_lTensor_exact'` to generalize the universe of
`N, N', N''` to any universe that is higher than `R` and `M`. |
iff_rTensor_exact' [Small.{v'} R] : Flat R M ↔
∀ ⦃N N' N'' : Type v'⦄ [AddCommGroup N] [AddCommGroup N'] [AddCommGroup N'']
[Module R N] [Module R N'] [Module R N''] ⦃f : N →ₗ[R] N'⦄ ⦃g : N' →ₗ[R] N''⦄,
Function.Exact f g → Function.Exact (f.rTensor M) (g.rTensor M) := by
refine ⟨fun _ ↦ rTensor_exact _, fun H ↦ iff_rTensor_preserves_injective_linearMap'.mpr
fun N' N'' _ _ _ _ f hf ↦ LinearMap.ker_eq_bot |>.mp <| eq_bot_iff |>.mpr
fun x (hx : _ = 0) ↦ ?_⟩
simpa [Eq.comm] using @H PUnit N' N'' _ _ _ _ _ _ 0 f (fun x ↦ by
simp_rw [Set.mem_range, LinearMap.zero_apply, exists_const]
exact (f.map_eq_zero_iff hf).trans eq_comm) x |>.mp hx | theorem | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | iff_rTensor_exact' | `M` is flat if and only if `- ⊗ M` is an exact functor. See
`Module.Flat.iff_rTensor_exact` to specialize the universe of `N, N', N''` to `Type (max u v)`. |
iff_rTensor_exact : Flat R M ↔
∀ ⦃N N' N'' : Type (max u v)⦄ [AddCommGroup N] [AddCommGroup N'] [AddCommGroup N'']
[Module R N] [Module R N'] [Module R N''] ⦃f : N →ₗ[R] N'⦄ ⦃g : N' →ₗ[R] N''⦄,
Function.Exact f g → Function.Exact (f.rTensor M) (g.rTensor M) :=
iff_rTensor_exact' | theorem | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | iff_rTensor_exact | `M` is flat if and only if `- ⊗ M` is an exact functor.
See `Module.Flat.iff_rTensor_exact'` to generalize the universe of
`N, N', N''` to any universe that is higher than `R` and `M`. |
includeLeft_injective [Module.Flat R A] (hb : Function.Injective (algebraMap R B)) :
Function.Injective (includeLeft : A →ₐ[S] A ⊗[R] B) := by
convert Module.Flat.lTensor_preserves_injective_linearMap (M := A) (Algebra.linearMap R B) hb
|>.comp (_root_.TensorProduct.rid R A).symm.injective
ext; simp | theorem | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | includeLeft_injective | null |
includeRight_injective [Module.Flat R B] (ha : Function.Injective (algebraMap R A)) :
Function.Injective (includeRight : B →ₐ[R] A ⊗[R] B) := by
convert Module.Flat.rTensor_preserves_injective_linearMap (M := B) (Algebra.linearMap R A) ha
|>.comp (_root_.TensorProduct.lid R B).symm.injective
ext; simp | theorem | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | includeRight_injective | null |
nontrivial_of_linearMap_injective_of_flat_left (f : R →ₗ[R] N) (h : Function.Injective f)
[Module.Flat R M] [Nontrivial M] : Nontrivial (M ⊗[R] N) :=
Module.Flat.lTensor_preserves_injective_linearMap (M := M) f h |>.comp
(TensorProduct.rid R M).symm.injective |>.nontrivial | theorem | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | nontrivial_of_linearMap_injective_of_flat_left | If `M`, `N` are `R`-modules, there exists an injective `R`-linear map from `R` to `N`,
and `M` is a nontrivial flat `R`-module, then `M ⊗[R] N` is nontrivial. |
nontrivial_of_linearMap_injective_of_flat_right (f : R →ₗ[R] M) (h : Function.Injective f)
[Module.Flat R N] [Nontrivial N] : Nontrivial (M ⊗[R] N) :=
Module.Flat.rTensor_preserves_injective_linearMap (M := N) f h |>.comp
(TensorProduct.lid R N).symm.injective |>.nontrivial
variable {R M N}
variable {P Q : Type*} [AddCommMonoid P] [Module R P] [AddCommMonoid Q] [Module R Q] | theorem | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | nontrivial_of_linearMap_injective_of_flat_right | If `M`, `N` are `R`-modules, there exists an injective `R`-linear map from `R` to `M`,
and `N` is a nontrivial flat `R`-module, then `M ⊗[R] N` is nontrivial. |
map_injective_of_flat_flat
(f : P →ₗ[R] M) (g : Q →ₗ[R] N) [Module.Flat R M] [Module.Flat R Q]
(hf : Function.Injective f) (hg : Function.Injective g) :
Function.Injective (TensorProduct.map f g) := by
rw [← LinearMap.lTensor_comp_rTensor]
exact (Module.Flat.lTensor_preserves_injective_linearMap g hg).comp
(Module.Flat.rTensor_preserves_injective_linearMap f hf) | lemma | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | map_injective_of_flat_flat | Tensor product of injective maps are injective under some flatness conditions.
Also see `TensorProduct.map_injective_of_flat_flat'` and
`TensorProduct.map_injective_of_flat_flat_of_isDomain` for different flatness conditions. |
map_injective_of_flat_flat'
(f : P →ₗ[R] M) (g : Q →ₗ[R] N) [Module.Flat R P] [Module.Flat R N]
(hf : Function.Injective f) (hg : Function.Injective g) :
Function.Injective (TensorProduct.map f g) := by
rw [← LinearMap.rTensor_comp_lTensor]
exact (Module.Flat.rTensor_preserves_injective_linearMap f hf).comp
(Module.Flat.lTensor_preserves_injective_linearMap g hg)
variable {ι κ : Type*} {v : ι → M} {w : κ → N} {s : Set ι} {t : Set κ} | lemma | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | map_injective_of_flat_flat' | Tensor product of injective maps are injective under some flatness conditions.
Also see `TensorProduct.map_injective_of_flat_flat` and
`TensorProduct.map_injective_of_flat_flat_of_isDomain` for different flatness conditions. |
_root_.LinearIndependent.tmul_of_flat_left [Module.Flat R M] (hv : LinearIndependent R v)
(hw : LinearIndependent R w) : LinearIndependent R fun i : ι × κ ↦ v i.1 ⊗ₜ[R] w i.2 := by
rw [LinearIndependent]
convert (TensorProduct.map_injective_of_flat_flat _ _ hv hw).comp
(finsuppTensorFinsupp' _ _ _).symm.injective
rw [← LinearEquiv.coe_toLinearMap, ← LinearMap.coe_comp]
congr!
ext i
simp [finsuppTensorFinsupp'_symm_single_eq_single_one_tmul] | lemma | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | _root_.LinearIndependent.tmul_of_flat_left | Tensor product of linearly independent families is linearly
independent under some flatness conditions.
The flatness condition could be removed over domains.
See `LinearIndependent.tmul_of_isDomain`. |
_root_.LinearIndependent.tmul_of_flat_right [Module.Flat R N] (hv : LinearIndependent R v)
(hw : LinearIndependent R w) : LinearIndependent R fun i : ι × κ ↦ v i.1 ⊗ₜ[R] w i.2 :=
(((TensorProduct.comm R N M).toLinearMap.linearIndependent_iff_of_injOn
(TensorProduct.comm R N M).injective.injOn).mpr
(hw.tmul_of_flat_left hv)).comp Prod.swap Prod.swap_bijective.injective | lemma | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | _root_.LinearIndependent.tmul_of_flat_right | Tensor product of linearly independent families is linearly
independent under some flatness conditions.
The flatness condition could be removed over domains.
See `LinearIndepOn.tmul_of_isDomain`. -/
nonrec lemma LinearIndepOn.tmul_of_flat_left [Module.Flat R M] (hv : LinearIndepOn R v s)
(hw : LinearIndepOn R w t) : LinearIndepOn R (fun i : ι × κ ↦ v i.1 ⊗ₜ[R] w i.2) (s ×ˢ t) :=
((hv.tmul_of_flat_left hw).comp _ (Equiv.Set.prod _ _).injective:)
/-- Tensor product of linearly independent families is linearly
independent under some flatness conditions.
The flatness condition could be removed over domains.
See `LinearIndependent.tmul_of_isDomain`. |
_root_.Module.Flat.tensorProduct_mapIncl_injective_of_right
[Module.Flat R M] [Module.Flat R q] : Function.Injective (mapIncl p q) :=
TensorProduct.map_injective_of_flat_flat _ _ p.subtype_injective q.subtype_injective | theorem | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | _root_.Module.Flat.tensorProduct_mapIncl_injective_of_right | Tensor product of linearly independent families is linearly
independent under some flatness conditions.
The flatness condition could be removed over domains.
See `LinearIndepOn.tmul_of_isDomain`. -/
nonrec lemma LinearIndepOn.tmul_of_flat_right [Module.Flat R N] (hv : LinearIndepOn R v s)
(hw : LinearIndepOn R w t) : LinearIndepOn R (fun i : ι × κ ↦ v i.1 ⊗ₜ[R] w i.2) (s ×ˢ t) :=
((hv.tmul_of_flat_right hw).comp _ (Equiv.Set.prod _ _).injective:)
variable (p : Submodule R M) (q : Submodule R N)
/-- If p and q are submodules of M and N respectively, and M and q are flat,
then `p ⊗ q → M ⊗ N` is injective. |
_root_.Module.Flat.tensorProduct_mapIncl_injective_of_left
[Module.Flat R p] [Module.Flat R N] : Function.Injective (mapIncl p q) :=
TensorProduct.map_injective_of_flat_flat' _ _ p.subtype_injective q.subtype_injective | theorem | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | _root_.Module.Flat.tensorProduct_mapIncl_injective_of_left | If p and q are submodules of M and N respectively, and N and p are flat,
then `p ⊗ q → M ⊗ N` is injective. |
nontrivial_of_algebraMap_injective_of_flat_left (h : Function.Injective (algebraMap R B))
[Module.Flat R A] [Nontrivial A] : Nontrivial (A ⊗[R] B) :=
TensorProduct.nontrivial_of_linearMap_injective_of_flat_left R A B (Algebra.linearMap R B) h | theorem | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | nontrivial_of_algebraMap_injective_of_flat_left | If `A`, `B` are `R`-algebras, `R` injects into `B`,
and `A` is a nontrivial flat `R`-algebra, then `A ⊗[R] B` is nontrivial. |
nontrivial_of_algebraMap_injective_of_flat_right (h : Function.Injective (algebraMap R A))
[Module.Flat R B] [Nontrivial B] : Nontrivial (A ⊗[R] B) :=
TensorProduct.nontrivial_of_linearMap_injective_of_flat_right R A B (Algebra.linearMap R A) h | theorem | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | nontrivial_of_algebraMap_injective_of_flat_right | If `A`, `B` are `R`-algebras, `R` injects into `A`,
and `B` is a nontrivial flat `R`-algebra, then `A ⊗[R] B` is nontrivial. |
map_id_injective_of_flat_left {g : M₁ →ₗ[R] N₂ →ₗ[R] N} (hg : IsTensorProduct g)
(i : M₂ →ₗ[R] N₂) (hi : Function.Injective i) [Module.Flat R M₁] :
Function.Injective (hf.map hg LinearMap.id i) := by
have h : hf.map hg LinearMap.id i = hg.equiv ∘ i.lTensor M₁ ∘ hf.equiv.symm :=
funext fun x ↦ hf.inductionOn x (by simp) (by simp) (fun _ _ hx hy ↦ by simp [hx, hy])
simpa [h] using Module.Flat.lTensor_preserves_injective_linearMap i hi | theorem | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | map_id_injective_of_flat_left | null |
map_id_injective_of_flat_right {g : N₁ →ₗ[R] M₂ →ₗ[R] N} (hg : IsTensorProduct g)
(i : M₁ →ₗ[R] N₁) (hi : Function.Injective i) [Module.Flat R M₂] :
Function.Injective (hf.map hg i LinearMap.id) := by
have h : hf.map hg i LinearMap.id = hg.equiv ∘ i.rTensor M₂ ∘ hf.equiv.symm :=
funext fun x ↦ hf.inductionOn x (by simp) (by simp) (fun _ _ hx hy ↦ by simp [hx, hy])
simpa [h] using Module.Flat.rTensor_preserves_injective_linearMap i hi | theorem | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | map_id_injective_of_flat_right | null |
map_injective_of_flat_right_left (h₁ : Function.Injective i₁) (h₂ : Function.Injective i₂)
[Module.Flat R M₂] [Module.Flat R N₁] : Function.Injective (hf.map hg i₁ i₂) := by
have h : hf.map hg i₁ i₂ = hg.equiv ∘ TensorProduct.map i₁ i₂ ∘ hf.equiv.symm :=
funext fun x ↦ hf.inductionOn x (by simp) (by simp) (fun _ _ hx hy ↦ by simp [hx, hy])
simpa [h] using map_injective_of_flat_flat i₁ i₂ h₁ h₂ | theorem | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | map_injective_of_flat_right_left | If `M₂` and `N₁` are flat `R`-modules, `i₁ : M₁ →ₗ[R] N₁` and `i₂ : M₂ →ₗ[R] N₂` are injective
linear maps, then the linear map `i : M ≅ M₁ ⊗[R] M₂ →ₗ[R] N₁ ⊗[R] N₂ ≅ N` induced by `i₁`
and `i₂` is injective.
See `IsTensorProduct.map_injective_of_flat'` for different flatness conditions. |
map_injective_of_flat_left_right (h₁ : Function.Injective i₁) (h₂ : Function.Injective i₂)
[Module.Flat R M₁] [Module.Flat R N₂] : Function.Injective (hf.map hg i₁ i₂) := by
have h : hf.map hg i₁ i₂ = hg.equiv ∘ TensorProduct.map i₁ i₂ ∘ hf.equiv.symm :=
funext fun x ↦ hf.inductionOn x (by simp) (by simp) (fun _ _ hx hy ↦ by simp [hx, hy])
simpa [h] using map_injective_of_flat_flat' i₁ i₂ h₁ h₂ | theorem | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | map_injective_of_flat_left_right | If `M₁` and `N₂` are flat `R`-modules, `i₁ : M₁ →ₗ[R] N₁` and `i₂ : M₂ →ₗ[R] N₂` are injective
linear maps, then the linear map `i : M ≅ M₁ ⊗[R] M₂ →ₗ[R] N₁ ⊗[R] N₂ ≅ N` induced by `i₁`
and `i₂` is injective.
See `IsTensorProduct.map_injective_of_flat` for different flatness conditions. |
IsSMulRegular.of_flat_of_isBaseChange {f : M →ₗ[R] N} (hf : IsBaseChange S f) {x : R}
(reg : IsSMulRegular M x) : IsSMulRegular N (algebraMap R S x) := by
have h := hf.map_id_injective_of_flat_left hf (LinearMap.lsmul R M x) reg
rwa [hf.map_id_lsmul_eq_lsmul_algebraMap] at h | theorem | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | IsSMulRegular.of_flat_of_isBaseChange | null |
IsSMulRegular.of_flat {x : R} (reg : IsSMulRegular R x) :
IsSMulRegular S (algebraMap R S x) :=
reg.of_flat_of_isBaseChange (IsBaseChange.linearMap R S) | theorem | RingTheory | [
"Mathlib.Algebra.Colimit.TensorProduct",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness",
"Mathlib.RingTheory.Finiteness.Small",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.TensorProduct.Finite"
] | Mathlib/RingTheory/Flat/Basic.lean | IsSMulRegular.of_flat | null |
lTensor_shortComplex_exact [Flat R M] (C : ShortComplex <| ModuleCat R) (hC : C.Exact) :
C.map (tensorLeft M) |>.Exact := by
rw [moduleCat_exact_iff_function_exact] at hC ⊢
exact lTensor_exact M hC | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Basic",
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic"
] | Mathlib/RingTheory/Flat/CategoryTheory.lean | lTensor_shortComplex_exact | null |
rTensor_shortComplex_exact [Flat R M] (C : ShortComplex <| ModuleCat R) (hC : C.Exact) :
C.map (tensorRight M) |>.Exact := by
rw [moduleCat_exact_iff_function_exact] at hC ⊢
exact rTensor_exact M hC | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Basic",
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic"
] | Mathlib/RingTheory/Flat/CategoryTheory.lean | rTensor_shortComplex_exact | null |
iff_lTensor_preserves_shortComplex_exact :
Flat R M ↔
∀ (C : ShortComplex <| ModuleCat R) (_ : C.Exact), (C.map (tensorLeft M) |>.Exact) :=
⟨fun _ _ ↦ lTensor_shortComplex_exact _ _, fun H ↦ iff_lTensor_exact.2
fun _ _ _ _ _ _ _ _ _ f g h ↦
moduleCat_exact_iff_function_exact _ |>.1 <|
H (.mk (ModuleCat.ofHom f) (ModuleCat.ofHom g)
(ModuleCat.hom_ext (DFunLike.ext _ _ h.apply_apply_eq_zero)))
(moduleCat_exact_iff_function_exact _ |>.2 h)⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Basic",
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic"
] | Mathlib/RingTheory/Flat/CategoryTheory.lean | iff_lTensor_preserves_shortComplex_exact | null |
iff_rTensor_preserves_shortComplex_exact :
Flat R M ↔
∀ (C : ShortComplex <| ModuleCat R) (_ : C.Exact), (C.map (tensorRight M) |>.Exact) :=
⟨fun _ _ ↦ rTensor_shortComplex_exact _ _, fun H ↦ iff_rTensor_exact.2
fun _ _ _ _ _ _ _ _ _ f g h ↦
moduleCat_exact_iff_function_exact _ |>.1 <|
H (.mk (ModuleCat.ofHom f) (ModuleCat.ofHom g)
(ModuleCat.hom_ext (DFunLike.ext _ _ h.apply_apply_eq_zero)))
(moduleCat_exact_iff_function_exact _ |>.2 h)⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Basic",
"Mathlib.Algebra.Homology.ShortComplex.ModuleCat",
"Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic"
] | Mathlib/RingTheory/Flat/CategoryTheory.lean | iff_rTensor_preserves_shortComplex_exact | null |
TensorProduct.map_injective_of_flat_flat_of_isDomain
(f : P →ₗ[R] M) (g : Q →ₗ[R] N) [H : Module.Flat R P] [Module.Flat R Q]
(hf : Injective f) (hg : Injective g) : Injective (TensorProduct.map f g) := by
let K := FractionRing R
refine .of_comp (f := TensorProduct.mk R K _ 1) ?_
have H₁ := TensorProduct.map_injective_of_flat_flat (f.baseChange K) (g.baseChange K)
(Module.Flat.lTensor_preserves_injective_linearMap f hf)
(Module.Flat.lTensor_preserves_injective_linearMap g hg)
have H₂ := (AlgebraTensorModule.cancelBaseChange R K K (K ⊗[R] P) Q).symm.injective
have H₃ := (AlgebraTensorModule.cancelBaseChange R K K (K ⊗[R] M) N).injective
have H₄ := (AlgebraTensorModule.assoc R R K K P Q).symm.injective
have H₅ := (AlgebraTensorModule.assoc R R K K M N).injective
have H₆ := Module.Flat.rTensor_preserves_injective_linearMap (M := P ⊗[R] Q)
(Algebra.linearMap R K) (FaithfulSMul.algebraMap_injective R K)
have H₇ := (TensorProduct.lid R (P ⊗[R] Q)).symm.injective
convert H₅.comp <| H₃.comp <| H₁.comp <| H₂.comp <| H₄.comp <| H₆.comp <| H₇
dsimp only [← LinearMap.coe_comp, ← LinearEquiv.coe_toLinearMap,
← @LinearMap.coe_restrictScalars R K]
congr! 1
ext p q
change (1 : K) ⊗ₜ[R] (f p ⊗ₜ[R] g q) = (AlgebraTensorModule.assoc R R K K M N)
(((1 : K) • (algebraMap R K) 1 ⊗ₜ[R] f p) ⊗ₜ[R] g q)
simp only [map_one, one_smul, AlgebraTensorModule.assoc_tmul]
variable {ι κ : Type*} {v : ι → M} {w : κ → N} {s : Set ι} {t : Set κ} | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Basis.VectorSpace",
"Mathlib.RingTheory.Flat.Localization"
] | Mathlib/RingTheory/Flat/Domain.lean | TensorProduct.map_injective_of_flat_flat_of_isDomain | Tensor product of injective maps over domains are injective under some flatness conditions.
Also see `TensorProduct.map_injective_of_flat_flat`
for different flatness conditions but without the domain assumption. |
LinearIndependent.tmul_of_isDomain (hv : LinearIndependent R v) (hw : LinearIndependent R w) :
LinearIndependent R fun i : ι × κ ↦ v i.1 ⊗ₜ[R] w i.2 := by
rw [LinearIndependent]
convert (TensorProduct.map_injective_of_flat_flat_of_isDomain _ _ hv hw).comp
(finsuppTensorFinsupp' _ _ _).symm.injective
rw [← LinearEquiv.coe_toLinearMap, ← LinearMap.coe_comp]
congr!
ext i
simp [finsuppTensorFinsupp'_symm_single_eq_single_one_tmul] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Basis.VectorSpace",
"Mathlib.RingTheory.Flat.Localization"
] | Mathlib/RingTheory/Flat/Domain.lean | LinearIndependent.tmul_of_isDomain | Tensor product of linearly independent families is linearly independent over domains.
This is true over non-domains if one of the modules is flat.
See `LinearIndependent.tmul_of_flat_left`. |
Module.Flat.ker_lTensor_eq [Module.Flat R M] :
LinearMap.ker (AlgebraTensorModule.lTensor S M f) =
LinearMap.range (AlgebraTensorModule.lTensor S M (LinearMap.ker f).subtype) := by
rw [← LinearMap.exact_iff]
exact Module.Flat.lTensor_exact M (LinearMap.exact_subtype_ker_map f) | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | Module.Flat.ker_lTensor_eq | null |
Module.Flat.eqLocus_lTensor_eq [Module.Flat R M] :
LinearMap.eqLocus (AlgebraTensorModule.lTensor S M f)
(AlgebraTensorModule.lTensor S M g) =
LinearMap.range (AlgebraTensorModule.lTensor S M (LinearMap.eqLocus f g).subtype) := by
rw [LinearMap.eqLocus_eq_ker_sub, LinearMap.eqLocus_eq_ker_sub]
rw [← map_sub, ker_lTensor_eq] | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | Module.Flat.eqLocus_lTensor_eq | null |
LinearMap.tensorEqLocusBil :
M →ₗ[S] LinearMap.eqLocus f g →ₗ[R]
LinearMap.eqLocus (AlgebraTensorModule.lTensor S M f)
(AlgebraTensorModule.lTensor S M g) where
toFun m :=
{ toFun := fun a ↦ ⟨m ⊗ₜ a, by simp [show f a = g a from a.property]⟩
map_add' := fun x y ↦ by simp [tmul_add]
map_smul' := fun r x ↦ by simp }
map_add' x y := by
ext
simp [add_tmul]
map_smul' r x := by
ext
simp [smul_tmul'] | def | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | LinearMap.tensorEqLocusBil | The bilinear map corresponding to `LinearMap.tensorEqLocus`. |
LinearMap.tensorKerBil :
M →ₗ[S] LinearMap.ker f →ₗ[R] LinearMap.ker (AlgebraTensorModule.lTensor S M f) where
toFun m :=
{ toFun := fun a ↦ ⟨m ⊗ₜ a, by simp⟩
map_add' := fun x y ↦ by simp [tmul_add]
map_smul' := fun r x ↦ by simp }
map_add' x y := by ext; simp [add_tmul]
map_smul' r x := by ext y; simp [smul_tmul'] | def | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | LinearMap.tensorKerBil | The bilinear map corresponding to `LinearMap.tensorKer`. |
LinearMap.tensorEqLocus : M ⊗[R] (LinearMap.eqLocus f g) →ₗ[S]
LinearMap.eqLocus (AlgebraTensorModule.lTensor S M f) (AlgebraTensorModule.lTensor S M g) :=
AlgebraTensorModule.lift (tensorEqLocusBil S M f g) | def | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | LinearMap.tensorEqLocus | The canonical map `M ⊗[R] eq(f, g) →ₗ[R] eq(𝟙 ⊗ f, 𝟙 ⊗ g)`. |
LinearMap.tensorKer : M ⊗[R] (LinearMap.ker f) →ₗ[S]
LinearMap.ker (AlgebraTensorModule.lTensor S M f) :=
AlgebraTensorModule.lift (f.tensorKerBil S M)
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | LinearMap.tensorKer | The canonical map `M ⊗[R] ker f →ₗ[R] ker (𝟙 ⊗ f)`. |
LinearMap.tensorKer_tmul (m : M) (x : LinearMap.ker f) :
(tensorKer S M f (m ⊗ₜ[R] x) : M ⊗[R] N) = m ⊗ₜ[R] (x : N) :=
rfl
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | LinearMap.tensorKer_tmul | null |
LinearMap.tensorKer_coe (x : M ⊗[R] (LinearMap.ker f)) :
(tensorKer S M f x : M ⊗[R] N) = (ker f).subtype.lTensor M x := by
induction x <;> simp_all
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | LinearMap.tensorKer_coe | null |
LinearMap.tensorEqLocus_tmul (m : M) (x : LinearMap.eqLocus f g) :
(tensorEqLocus S M f g (m ⊗ₜ[R] x) : M ⊗[R] N) = m ⊗ₜ[R] (x : N) :=
rfl
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | LinearMap.tensorEqLocus_tmul | null |
LinearMap.tensorEqLocus_coe (x : M ⊗[R] (LinearMap.eqLocus f g)) :
(tensorEqLocus S M f g x : M ⊗[R] N) = (eqLocus f g).subtype.lTensor M x := by
induction x <;> simp_all | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | LinearMap.tensorEqLocus_coe | null |
private LinearMap.tensorKerInv [Module.Flat R M] :
ker (AlgebraTensorModule.lTensor S M f) →ₗ[S] M ⊗[R] (ker f) :=
LinearMap.codRestrictOfInjective (LinearMap.ker (AlgebraTensorModule.lTensor S M f)).subtype
(AlgebraTensorModule.lTensor S M (ker f).subtype)
(Module.Flat.lTensor_preserves_injective_linearMap (ker f).subtype
(ker f).injective_subtype) (by simp [Module.Flat.ker_lTensor_eq])
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | LinearMap.tensorKerInv | null |
private LinearMap.lTensor_ker_subtype_tensorKerInv [Module.Flat R M]
(x : ker (AlgebraTensorModule.lTensor S M f)) :
(lTensor M (ker f).subtype) ((tensorKerInv S M f) x) = x := by
rw [← AlgebraTensorModule.coe_lTensor (A := S)]
simp [LinearMap.tensorKerInv] | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | LinearMap.lTensor_ker_subtype_tensorKerInv | null |
private LinearMap.tensorEqLocusInv [Module.Flat R M] :
eqLocus (AlgebraTensorModule.lTensor S M f) (AlgebraTensorModule.lTensor S M g) →ₗ[S]
M ⊗[R] (eqLocus f g) :=
LinearMap.codRestrictOfInjective
(LinearMap.eqLocus (AlgebraTensorModule.lTensor S M f)
(AlgebraTensorModule.lTensor S M g)).subtype
(AlgebraTensorModule.lTensor S M (eqLocus f g).subtype)
(Module.Flat.lTensor_preserves_injective_linearMap (eqLocus f g).subtype
(eqLocus f g).injective_subtype) (by simp [Module.Flat.eqLocus_lTensor_eq])
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | LinearMap.tensorEqLocusInv | null |
private LinearMap.lTensor_eqLocus_subtype_tensorEqLocusInv [Module.Flat R M]
(x : eqLocus (AlgebraTensorModule.lTensor S M f) (AlgebraTensorModule.lTensor S M g)) :
(lTensor M (eqLocus f g).subtype) (tensorEqLocusInv S M f g x) = x := by
rw [← AlgebraTensorModule.coe_lTensor (A := S)]
simp [LinearMap.tensorEqLocusInv] | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | LinearMap.lTensor_eqLocus_subtype_tensorEqLocusInv | null |
LinearMap.tensorKerEquiv [Module.Flat R M] :
M ⊗[R] LinearMap.ker f ≃ₗ[S] LinearMap.ker (AlgebraTensorModule.lTensor S M f) :=
LinearEquiv.ofLinear (LinearMap.tensorKer S M f) (LinearMap.tensorKerInv S M f)
(by ext x; simp)
(by
ext m x
apply (Module.Flat.lTensor_preserves_injective_linearMap (ker f).subtype
(ker f).injective_subtype)
simp)
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | LinearMap.tensorKerEquiv | If `M` is `R`-flat, the canonical map `M ⊗[R] ker f →ₗ[R] ker (𝟙 ⊗ f)` is an isomorphism. |
LinearMap.tensorKerEquiv_apply [Module.Flat R M] (x : M ⊗[R] ker f) :
tensorKerEquiv S M f x = tensorKer S M f x :=
rfl
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | LinearMap.tensorKerEquiv_apply | null |
LinearMap.lTensor_ker_subtype_tensorKerEquiv_symm [Module.Flat R M]
(x : ker (AlgebraTensorModule.lTensor S M f)) :
(lTensor M (ker f).subtype) ((tensorKerEquiv S M f).symm x) = x :=
lTensor_ker_subtype_tensorKerInv S M f x | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | LinearMap.lTensor_ker_subtype_tensorKerEquiv_symm | null |
LinearMap.tensorEqLocusEquiv [Module.Flat R M] :
M ⊗[R] eqLocus f g ≃ₗ[S]
eqLocus (AlgebraTensorModule.lTensor S M f)
(AlgebraTensorModule.lTensor S M g) :=
LinearEquiv.ofLinear (LinearMap.tensorEqLocus S M f g) (LinearMap.tensorEqLocusInv S M f g)
(by ext; simp)
(by
ext m x
apply (Module.Flat.lTensor_preserves_injective_linearMap (eqLocus f g).subtype
(eqLocus f g).injective_subtype)
simp)
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | LinearMap.tensorEqLocusEquiv | If `M` is `R`-flat, the canonical map `M ⊗[R] eq(f, g) →ₗ[S] eq (𝟙 ⊗ f, 𝟙 ⊗ g)` is an
isomorphism. |
LinearMap.tensorEqLocusEquiv_apply [Module.Flat R M] (x : M ⊗[R] LinearMap.eqLocus f g) :
LinearMap.tensorEqLocusEquiv S M f g x = LinearMap.tensorEqLocus S M f g x :=
rfl
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | LinearMap.tensorEqLocusEquiv_apply | null |
LinearMap.lTensor_eqLocus_subtype_tensoreqLocusEquiv_symm [Module.Flat R M]
(x : eqLocus (AlgebraTensorModule.lTensor S M f) (AlgebraTensorModule.lTensor S M g)) :
(lTensor M (eqLocus f g).subtype) ((tensorEqLocusEquiv S M f g).symm x) = x :=
lTensor_eqLocus_subtype_tensorEqLocusInv S M f g x | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | LinearMap.lTensor_eqLocus_subtype_tensoreqLocusEquiv_symm | null |
private AlgHom.tensorEqualizerAux :
T ⊗[R] AlgHom.equalizer f g →ₗ[S]
AlgHom.equalizer (Algebra.TensorProduct.map (AlgHom.id S T) f)
(Algebra.TensorProduct.map (AlgHom.id S T) g) :=
LinearMap.tensorEqLocus S T (f : A →ₗ[R] B) (g : A →ₗ[R] B)
private local instance : AddHomClass (A →ₐ[R] B) A B := inferInstance
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | AlgHom.tensorEqualizerAux | null |
private AlgHom.coe_tensorEqualizerAux (x : T ⊗[R] AlgHom.equalizer f g) :
(AlgHom.tensorEqualizerAux S T f g x : T ⊗[R] A) =
Algebra.TensorProduct.map (AlgHom.id S T) (AlgHom.equalizer f g).val x := by
induction x with
| zero => rfl
| tmul => rfl
| add x y hx hy => simp [hx, hy] | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | AlgHom.coe_tensorEqualizerAux | null |
private AlgHom.tensorEqualizerAux_mul (x y : T ⊗[R] AlgHom.equalizer f g) :
AlgHom.tensorEqualizerAux S T f g (x * y) =
AlgHom.tensorEqualizerAux S T f g x *
AlgHom.tensorEqualizerAux S T f g y := by
apply Subtype.ext
rw [AlgHom.coe_tensorEqualizerAux]
simp | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | AlgHom.tensorEqualizerAux_mul | null |
AlgHom.tensorEqualizer :
T ⊗[R] AlgHom.equalizer f g →ₐ[S]
AlgHom.equalizer (Algebra.TensorProduct.map (AlgHom.id S T) f)
(Algebra.TensorProduct.map (AlgHom.id S T) g) :=
AlgHom.ofLinearMap (AlgHom.tensorEqualizerAux S T f g)
rfl (AlgHom.tensorEqualizerAux_mul S T f g)
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | AlgHom.tensorEqualizer | The canonical map `T ⊗[R] eq(f, g) →ₐ[S] eq (𝟙 ⊗ f, 𝟙 ⊗ g)`. |
AlgHom.coe_tensorEqualizer (x : T ⊗[R] AlgHom.equalizer f g) :
(AlgHom.tensorEqualizer S T f g x : T ⊗[R] A) =
Algebra.TensorProduct.map (AlgHom.id S T) (AlgHom.equalizer f g).val x :=
AlgHom.coe_tensorEqualizerAux S T f g x | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | AlgHom.coe_tensorEqualizer | null |
AlgHom.tensorEqualizerEquiv [Module.Flat R T] :
T ⊗[R] AlgHom.equalizer f g ≃ₐ[S]
AlgHom.equalizer (Algebra.TensorProduct.map (AlgHom.id S T) f)
(Algebra.TensorProduct.map (AlgHom.id S T) g) :=
AlgEquiv.ofLinearEquiv (LinearMap.tensorEqLocusEquiv S T f.toLinearMap g.toLinearMap)
rfl (AlgHom.tensorEqualizerAux_mul S T f g)
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | AlgHom.tensorEqualizerEquiv | If `T` is `R`-flat, the canonical map
`T ⊗[R] eq(f, g) →ₐ[S] eq (𝟙 ⊗ f, 𝟙 ⊗ g)` is an isomorphism. |
AlgHom.tensorEqualizerEquiv_apply [Module.Flat R T]
(x : T ⊗[R] AlgHom.equalizer f g) :
AlgHom.tensorEqualizerEquiv S T f g x = AlgHom.tensorEqualizer S T f g x :=
rfl | lemma | RingTheory | [
"Mathlib.RingTheory.Flat.Basic"
] | Mathlib/RingTheory/Flat/Equalizer.lean | AlgHom.tensorEqualizerEquiv_apply | null |
IsTrivialRelation : Prop :=
∃ (k : ℕ) (a : ι → Fin k → R) (y : Fin k → M),
(∀ i, x i = ∑ j, a i j • y j) ∧ ∀ j, ∑ i, f i * a i j = 0
variable {f x} | abbrev | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.LinearAlgebra.TensorProduct.Vanishing",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/Flat/EquationalCriterion.lean | IsTrivialRelation | The proposition that the relation $\sum_i f_i x_i = 0$ in $M$ is trivial.
That is, there exist a finite index type $\kappa$ = `Fin k`, elements
$(y_j)_{j \in \kappa}$ of $M$, and elements $(a_{ij})_{i \in \iota, j \in \kappa}$ of $R$
such that for all $i$,
$$x_i = \sum_j a_{ij} y_j$$
and for all $j$,
$$\sum_i f_i a_{ij} = 0.$$
By `Module.sum_smul_eq_zero_of_isTrivialRelation`, this condition implies $\sum_i f_i x_i = 0$. |
isTrivialRelation_iff_vanishesTrivially :
IsTrivialRelation f x ↔ VanishesTrivially R f x := by
simp only [IsTrivialRelation, VanishesTrivially, smul_eq_mul, mul_comm] | theorem | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.LinearAlgebra.TensorProduct.Vanishing",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/Flat/EquationalCriterion.lean | isTrivialRelation_iff_vanishesTrivially | `Module.IsTrivialRelation` is equivalent to the predicate `TensorProduct.VanishesTrivially`
defined in `Mathlib/LinearAlgebra/TensorProduct/Vanishing.lean`. |
_root_.Equiv.isTrivialRelation_comp {κ} [Fintype κ] (e : κ ≃ ι) :
IsTrivialRelation (f ∘ e) (x ∘ e) ↔ IsTrivialRelation f x := by
simp_rw [isTrivialRelation_iff_vanishesTrivially, e.vanishesTrivially_comp] | theorem | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.LinearAlgebra.TensorProduct.Vanishing",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/Flat/EquationalCriterion.lean | _root_.Equiv.isTrivialRelation_comp | null |
sum_smul_eq_zero_of_isTrivialRelation (h : IsTrivialRelation f x) :
∑ i, f i • x i = 0 := by
simpa using
congr_arg (TensorProduct.lid R M) <|
sum_tmul_eq_zero_of_vanishesTrivially R (isTrivialRelation_iff_vanishesTrivially.mp h) | theorem | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.LinearAlgebra.TensorProduct.Vanishing",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/Flat/EquationalCriterion.lean | sum_smul_eq_zero_of_isTrivialRelation | If the relation given by $(f_i)_{i \in \iota}$ and $(x_i)_{i \in \iota}$ is trivial, then
$\sum_i f_i x_i$ is actually equal to $0$. |
@[stacks 00HK, stacks 058D "(1) ↔ (2)"]
tfae_equational_criterion : List.TFAE [
Flat R M,
∀ I : Ideal R, Function.Injective (rTensor M I.subtype),
∀ {l : ℕ} {f : Fin l → R} {x : Fin l → M}, ∑ i, f i ⊗ₜ x i = (0 : R ⊗[R] M) →
VanishesTrivially R f x,
∀ {l : ℕ} {f : Fin l → R} {x : Fin l → M}, ∑ i, f i • x i = 0 → IsTrivialRelation f x,
∀ {l : ℕ} {f : Fin l →₀ R} {x : (Fin l →₀ R) →ₗ[R] M}, x f = 0 →
∃ (k : ℕ) (a : (Fin l →₀ R) →ₗ[R] (Fin k →₀ R)) (y : (Fin k →₀ R) →ₗ[R] M),
x = y ∘ₗ a ∧ a f = 0] := by
classical
tfae_have 1 ↔ 2 := iff_rTensor_injective'
tfae_have 3 ↔ 2 := forall_vanishesTrivially_iff_forall_rTensor_injective R
tfae_have 3 ↔ 4 := by
simp [(TensorProduct.lid R M).injective.eq_iff.symm, isTrivialRelation_iff_vanishesTrivially]
tfae_have 4 → 5
| h₄, l, f, x, hfx => by
let f' : Fin l → R := f
let x' : Fin l → M := fun i ↦ x (single i 1)
have := calc
∑ i, f' i • x' i
_ = ∑ i, f i • x (single i 1) := rfl
_ = x (∑ i, f i • Finsupp.single i 1) := by simp_rw [map_sum, map_smul]
_ = x f := by simp_rw [smul_single, smul_eq_mul, mul_one, univ_sum_single]
_ = 0 := hfx
obtain ⟨k, a', y', ⟨ha'y', ha'⟩⟩ := h₄ this
use k
use Finsupp.linearCombination R (fun i ↦ equivFunOnFinite.symm (a' i))
use Finsupp.linearCombination R y'
constructor
· apply Finsupp.basisSingleOne.ext
intro i
simpa [linearCombination_apply, sum_fintype, Finsupp.single_apply] using ha'y' i
· ext j
simp only [linearCombination_apply, zero_smul, implies_true, sum_fintype, finset_sum_apply]
exact ha' j
tfae_have 5 → 4
| h₅, l, f, x, hfx => by
let f' : Fin l →₀ R := equivFunOnFinite.symm f
let x' : (Fin l →₀ R) →ₗ[R] M := Finsupp.linearCombination R x
have : x' f' = 0 := by simpa [x', f', linearCombination_apply, sum_fintype] using hfx
obtain ⟨k, a', y', ha'y', ha'⟩ := h₅ this
refine ⟨k, fun i ↦ a' (single i 1), fun j ↦ y' (single j 1), fun i ↦ ?_, fun j ↦ ?_⟩
· simpa [x', ← map_smul, ← map_sum, smul_single] using
LinearMap.congr_fun ha'y' (Finsupp.single i 1)
· simp_rw [← smul_eq_mul, ← Finsupp.smul_apply, ← map_smul, ← finset_sum_apply, ← map_sum,
smul_single, smul_eq_mul, mul_one,
← (fun _ ↦ equivFunOnFinite_symm_apply_toFun _ _ : ∀ x, f' x = f x), univ_sum_single]
simpa using DFunLike.congr_fun ha' j
tfae_finish | theorem | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.LinearAlgebra.TensorProduct.Vanishing",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/Flat/EquationalCriterion.lean | tfae_equational_criterion | **Equational criterion for flatness**, combined form.
Let $M$ be a module over a commutative ring $R$. The following are equivalent:
* $M$ is flat.
* For all ideals $I \subseteq R$, the map $I \otimes M \to M$ is injective.
* Every $\sum_i f_i \otimes x_i$ that vanishes in $R \otimes M$ vanishes trivially.
* Every relation $\sum_i f_i x_i = 0$ in $M$ is trivial.
* For all finite free modules $R^l$, all elements $f \in R^l$, and all linear maps
$x \colon R^l \to M$ such that $x(f) = 0$, there exist a finite free module $R^k$ and
linear maps $a \colon R^l \to R^k$ and $y \colon R^k \to M$ such
that $x = y \circ a$ and $a(f) = 0$. |
@[stacks 00HK]
iff_forall_isTrivialRelation : Flat R M ↔ ∀ {l : ℕ} {f : Fin l → R} {x : Fin l → M},
∑ i, f i • x i = 0 → IsTrivialRelation f x :=
(tfae_equational_criterion R M).out 0 3 | theorem | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.LinearAlgebra.TensorProduct.Vanishing",
"Mathlib.RingTheory.Flat.Tensor"
] | Mathlib/RingTheory/Flat/EquationalCriterion.lean | iff_forall_isTrivialRelation | **Equational criterion for flatness**:
a module $M$ is flat if and only if every relation $\sum_i f_i x_i = 0$ in $M$ is trivial. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.