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 ⌀ |
|---|---|---|---|---|---|---|
@[simp] trace_self : trace R R = LinearMap.id := by
ext; simpa using trace_algebraMap_of_basis (.singleton (Fin 1) R) 1 | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FiniteDimensional.Lemmas",
"Mathlib.LinearAlgebra.Matrix.BilinearForm",
"Mathlib.LinearAlgebra.Trace"
] | Mathlib/RingTheory/Trace/Defs.lean | trace_self | The trace map from `R` to itself is the identity map. |
trace_self_apply (a) : trace R R a = a := by simp | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FiniteDimensional.Lemmas",
"Mathlib.LinearAlgebra.Matrix.BilinearForm",
"Mathlib.LinearAlgebra.Trace"
] | Mathlib/RingTheory/Trace/Defs.lean | trace_self_apply | null |
@[simp]
trace_algebraMap [StrongRankCondition R] [Module.Free R S] (x : R) :
trace R S (algebraMap R S x) = finrank R S • x := by
by_cases H : ∃ s : Finset S, Nonempty (Basis s R S)
· rw [trace_algebraMap_of_basis H.choose_spec.some, finrank_eq_card_basis H.choose_spec.some]
· simp [trace_eq_zero_of_not_exists_basis R H, finrank_eq_zero_of_not_exists_basis_finset H] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FiniteDimensional.Lemmas",
"Mathlib.LinearAlgebra.Matrix.BilinearForm",
"Mathlib.LinearAlgebra.Trace"
] | Mathlib/RingTheory/Trace/Defs.lean | trace_algebraMap | If `x` is in the base field `K`, then the trace is `[L : K] * x`.
(If `L` is not finite-dimensional over `K`, then `trace` and `finrank` return `0`.) |
trace_trace_of_basis [Algebra S T] [IsScalarTower R S T] {ι κ : Type*} [Finite ι]
[Finite κ] (b : Basis ι R S) (c : Basis κ S T) (x : T) :
trace R S (trace S T x) = trace R T x := by
haveI := Classical.decEq ι
haveI := Classical.decEq κ
cases nonempty_fintype ι
cases nonempty_fintype κ
rw [trace_eq_matrix_trace (b.smulTower c), trace_eq_matrix_trace b, trace_eq_matrix_trace c,
Matrix.trace, Matrix.trace, Matrix.trace, ← Finset.univ_product_univ, Finset.sum_product]
refine Finset.sum_congr rfl fun i _ ↦ ?_
simp only [map_sum, smulTower_leftMulMatrix, Finset.sum_apply, Matrix.diag,
Finset.sum_apply i (Finset.univ : Finset κ) fun y => leftMulMatrix b (leftMulMatrix c x y y)] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FiniteDimensional.Lemmas",
"Mathlib.LinearAlgebra.Matrix.BilinearForm",
"Mathlib.LinearAlgebra.Trace"
] | Mathlib/RingTheory/Trace/Defs.lean | trace_trace_of_basis | null |
trace_comp_trace_of_basis [Algebra S T] [IsScalarTower R S T] {ι κ : Type*} [Finite ι]
[Finite κ] (b : Basis ι R S) (c : Basis κ S T) :
(trace R S).comp ((trace S T).restrictScalars R) = trace R T := by
ext
rw [LinearMap.comp_apply, LinearMap.restrictScalars_apply, trace_trace_of_basis b c]
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FiniteDimensional.Lemmas",
"Mathlib.LinearAlgebra.Matrix.BilinearForm",
"Mathlib.LinearAlgebra.Trace"
] | Mathlib/RingTheory/Trace/Defs.lean | trace_comp_trace_of_basis | null |
trace_trace [Algebra S T] [IsScalarTower R S T]
[Module.Free R S] [Module.Finite R S] [Module.Free S T] [Module.Finite S T] (x : T) :
trace R S (trace S T x) = trace R T x :=
trace_trace_of_basis (Module.Free.chooseBasis R S) (Module.Free.chooseBasis S T) x | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FiniteDimensional.Lemmas",
"Mathlib.LinearAlgebra.Matrix.BilinearForm",
"Mathlib.LinearAlgebra.Trace"
] | Mathlib/RingTheory/Trace/Defs.lean | trace_trace | null |
@[simp, stacks 0BIJ "Trace"]
trace_comp_trace [Algebra S T] [IsScalarTower R S T]
[Module.Free R S] [Module.Finite R S] [Module.Free S T] [Module.Finite S T] :
(trace R S).comp ((trace S T).restrictScalars R) = trace R T :=
LinearMap.ext trace_trace
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FiniteDimensional.Lemmas",
"Mathlib.LinearAlgebra.Matrix.BilinearForm",
"Mathlib.LinearAlgebra.Trace"
] | Mathlib/RingTheory/Trace/Defs.lean | trace_comp_trace | Let `T / S / R` be a tower of finite extensions of fields. Then
$\text{Trace}_{T/R} = \text{Trace}_{S/R} \circ \text{Trace}_{T/S}$. |
trace_prod_apply [Module.Free R S] [Module.Free R T] [Module.Finite R S] [Module.Finite R T]
(x : S × T) : trace R (S × T) x = trace R S x.fst + trace R T x.snd := by
nontriviality R
let f := (lmul R S).toLinearMap.prodMap (lmul R T).toLinearMap
have : (lmul R (S × T)).toLinearMap = (prodMapLinear R S T S T R).comp f :=
LinearMap.ext₂ Prod.mul_def
simp_rw [trace, this]
exact trace_prodMap' _ _ | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FiniteDimensional.Lemmas",
"Mathlib.LinearAlgebra.Matrix.BilinearForm",
"Mathlib.LinearAlgebra.Trace"
] | Mathlib/RingTheory/Trace/Defs.lean | trace_prod_apply | null |
trace_prod [Module.Free R S] [Module.Free R T] [Module.Finite R S] [Module.Finite R T] :
trace R (S × T) = (trace R S).coprod (trace R T) :=
LinearMap.ext fun p => by rw [coprod_apply, trace_prod_apply] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FiniteDimensional.Lemmas",
"Mathlib.LinearAlgebra.Matrix.BilinearForm",
"Mathlib.LinearAlgebra.Trace"
] | Mathlib/RingTheory/Trace/Defs.lean | trace_prod | null |
@[stacks 0BIK "Trace pairing"]
noncomputable traceForm : BilinForm R S :=
LinearMap.compr₂ (lmul R S).toLinearMap (trace R S)
variable {S}
@[simp] | def | RingTheory | [
"Mathlib.LinearAlgebra.FiniteDimensional.Lemmas",
"Mathlib.LinearAlgebra.Matrix.BilinearForm",
"Mathlib.LinearAlgebra.Trace"
] | Mathlib/RingTheory/Trace/Defs.lean | traceForm | The `traceForm` maps `x y : S` to the trace of `x * y`.
It is a symmetric bilinear form and is nondegenerate if the extension is separable. |
traceForm_apply (x y : S) : traceForm R S x y = trace R S (x * y) :=
rfl | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FiniteDimensional.Lemmas",
"Mathlib.LinearAlgebra.Matrix.BilinearForm",
"Mathlib.LinearAlgebra.Trace"
] | Mathlib/RingTheory/Trace/Defs.lean | traceForm_apply | null |
traceForm_isSymm : (traceForm R S).IsSymm :=
⟨fun _ _ => congr_arg (trace R S) (mul_comm _ _)⟩ | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FiniteDimensional.Lemmas",
"Mathlib.LinearAlgebra.Matrix.BilinearForm",
"Mathlib.LinearAlgebra.Trace"
] | Mathlib/RingTheory/Trace/Defs.lean | traceForm_isSymm | null |
traceForm_toMatrix [DecidableEq ι] (b : Basis ι R S) (i j) :
BilinForm.toMatrix b (traceForm R S) i j = trace R S (b i * b j) := by
rw [BilinForm.toMatrix_apply, traceForm_apply] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FiniteDimensional.Lemmas",
"Mathlib.LinearAlgebra.Matrix.BilinearForm",
"Mathlib.LinearAlgebra.Trace"
] | Mathlib/RingTheory/Trace/Defs.lean | traceForm_toMatrix | null |
Algebra.trace_quotient_mk [IsLocalRing R] (x : S) :
Algebra.trace (R ⧸ p) (S ⧸ pS) (Ideal.Quotient.mk pS x) =
Ideal.Quotient.mk p (Algebra.trace R S x) := by
classical
let ι := Module.Free.ChooseBasisIndex R S
let b : Module.Basis ι R S := Module.Free.chooseBasis R S
rw [trace_eq_matrix_trace b, trace_eq_matrix_trace (basisQuotient b), AddMonoidHom.map_trace]
congr 1
ext i j
simp only [leftMulMatrix_apply, coe_lmul_eq_mul, LinearMap.toMatrix_apply,
basisQuotient_apply, LinearMap.mul_apply', Matrix.map_apply, ← map_mul,
basisQuotient_repr] | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict",
"Mathlib.RingTheory.LocalRing.Quotient"
] | Mathlib/RingTheory/Trace/Quotient.lean | Algebra.trace_quotient_mk | null |
noncomputable
equivQuotMaximalIdealOfIsLocalization : R ⧸ p ≃+* Rₚ ⧸ maximalIdeal Rₚ := by
refine (Ideal.quotEquivOfEq ?_).trans
(RingHom.quotientKerEquivOfSurjective (f := algebraMap R (Rₚ ⧸ maximalIdeal Rₚ)) ?_)
· rw [IsScalarTower.algebraMap_eq R Rₚ, ← RingHom.comap_ker,
Ideal.Quotient.algebraMap_eq, Ideal.mk_ker, IsLocalization.AtPrime.comap_maximalIdeal Rₚ p]
· intro x
obtain ⟨x, rfl⟩ := Ideal.Quotient.mk_surjective x
obtain ⟨x, s, rfl⟩ := IsLocalization.mk'_surjective p.primeCompl x
obtain ⟨s', hs⟩ := Ideal.Quotient.mk_surjective (I := p) (Ideal.Quotient.mk p s)⁻¹
simp only [IsScalarTower.algebraMap_eq R Rₚ (Rₚ ⧸ _),
Ideal.Quotient.algebraMap_eq, RingHom.comp_apply]
use x * s'
rw [← sub_eq_zero, ← map_sub, Ideal.Quotient.eq_zero_iff_mem]
have : algebraMap R Rₚ s ∉ maximalIdeal Rₚ := by
rw [← Ideal.mem_comap, IsLocalization.AtPrime.comap_maximalIdeal Rₚ p]
exact s.prop
refine ((inferInstanceAs <| (maximalIdeal Rₚ).IsPrime).mem_or_mem ?_).resolve_left this
rw [mul_sub, IsLocalization.mul_mk'_eq_mk'_of_mul, IsLocalization.mk'_mul_cancel_left,
← map_mul, ← map_sub, ← Ideal.mem_comap, IsLocalization.AtPrime.comap_maximalIdeal Rₚ p,
mul_left_comm, ← Ideal.Quotient.eq_zero_iff_mem, map_sub, map_mul, map_mul, hs,
mul_inv_cancel₀, mul_one, sub_self]
rw [Ne, Ideal.Quotient.eq_zero_iff_mem]
exact s.prop | def | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict",
"Mathlib.RingTheory.LocalRing.Quotient"
] | Mathlib/RingTheory/Trace/Quotient.lean | equivQuotMaximalIdealOfIsLocalization | The isomorphism `R ⧸ p ≃+* Rₚ ⧸ maximalIdeal Rₚ`, where `Rₚ` satisfies
`IsLocalization.AtPrime Rₚ p`. In particular, localization preserves the residue field. |
IsLocalization.AtPrime.map_eq_maximalIdeal :
p.map (algebraMap R Rₚ) = maximalIdeal Rₚ := by
convert congr_arg (Ideal.map (algebraMap R Rₚ))
(IsLocalization.AtPrime.comap_maximalIdeal Rₚ p).symm
rw [map_comap p.primeCompl]
local notation "pS" => Ideal.map (algebraMap R S) p
local notation "pSₚ" => Ideal.map (algebraMap Rₚ Sₚ) (maximalIdeal Rₚ) | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict",
"Mathlib.RingTheory.LocalRing.Quotient"
] | Mathlib/RingTheory/Trace/Quotient.lean | IsLocalization.AtPrime.map_eq_maximalIdeal | null |
comap_map_eq_map_of_isLocalization_algebraMapSubmonoid :
(Ideal.map (algebraMap R Sₚ) p).comap (algebraMap S Sₚ) = pS := by
rw [IsScalarTower.algebraMap_eq R S Sₚ, ← Ideal.map_map, eq_comm]
apply Ideal.le_comap_map.antisymm
intro x hx
obtain ⟨α, hα, hαx⟩ : ∃ α ∉ p, α • x ∈ pS := by
have ⟨⟨y, s⟩, hy⟩ := (IsLocalization.mem_map_algebraMap_iff
(Algebra.algebraMapSubmonoid S p.primeCompl) Sₚ).mp hx
rw [← map_mul,
IsLocalization.eq_iff_exists (Algebra.algebraMapSubmonoid S p.primeCompl)] at hy
obtain ⟨c, hc⟩ := hy
obtain ⟨α, hα, e⟩ := (c * s).prop
refine ⟨α, hα, ?_⟩
rw [Algebra.smul_def, e, Submonoid.coe_mul, mul_assoc, mul_comm _ x, hc]
exact Ideal.mul_mem_left _ _ y.prop
obtain ⟨β, γ, hγ, hβ⟩ : ∃ β γ, γ ∈ p ∧ β * α = 1 + γ := by
obtain ⟨β, hβ⟩ := Ideal.Quotient.mk_surjective (I := p) (Ideal.Quotient.mk p α)⁻¹
refine ⟨β, β * α - 1, ?_, ?_⟩
· rw [← Ideal.Quotient.eq_zero_iff_mem, map_sub, map_one,
map_mul, hβ, inv_mul_cancel₀, sub_self]
rwa [Ne, Ideal.Quotient.eq_zero_iff_mem]
· rw [add_sub_cancel]
have := Ideal.mul_mem_left _ (algebraMap _ _ β) hαx
rw [← Algebra.smul_def, smul_smul, hβ, add_smul, one_smul] at this
refine (Submodule.add_mem_iff_left _ ?_).mp this
rw [Algebra.smul_def]
apply Ideal.mul_mem_right
exact Ideal.mem_map_of_mem _ hγ
variable (S Sₚ) | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict",
"Mathlib.RingTheory.LocalRing.Quotient"
] | Mathlib/RingTheory/Trace/Quotient.lean | comap_map_eq_map_of_isLocalization_algebraMapSubmonoid | null |
noncomputable
quotMapEquivQuotMapMaximalIdealOfIsLocalization : S ⧸ pS ≃+* Sₚ ⧸ pSₚ := by
haveI h : pSₚ = Ideal.map (algebraMap S Sₚ) pS := by
rw [← IsLocalization.AtPrime.map_eq_maximalIdeal p Rₚ, Ideal.map_map,
← IsScalarTower.algebraMap_eq, Ideal.map_map, ← IsScalarTower.algebraMap_eq]
refine (Ideal.quotEquivOfEq ?_).trans
(RingHom.quotientKerEquivOfSurjective (f := algebraMap S (Sₚ ⧸ pSₚ)) ?_)
· rw [IsScalarTower.algebraMap_eq S Sₚ, Ideal.Quotient.algebraMap_eq, ← RingHom.comap_ker,
Ideal.mk_ker, h, Ideal.map_map, ← IsScalarTower.algebraMap_eq,
comap_map_eq_map_of_isLocalization_algebraMapSubmonoid]
· intro x
obtain ⟨x, rfl⟩ := Ideal.Quotient.mk_surjective x
obtain ⟨x, s, rfl⟩ := IsLocalization.mk'_surjective
(Algebra.algebraMapSubmonoid S p.primeCompl) x
obtain ⟨α, hα : α ∉ p, e⟩ := s.prop
obtain ⟨β, γ, hγ, hβ⟩ : ∃ β γ, γ ∈ p ∧ α * β = 1 + γ := by
obtain ⟨β, hβ⟩ := Ideal.Quotient.mk_surjective (I := p) (Ideal.Quotient.mk p α)⁻¹
refine ⟨β, α * β - 1, ?_, ?_⟩
· rw [← Ideal.Quotient.eq_zero_iff_mem, map_sub, map_one,
map_mul, hβ, mul_inv_cancel₀, sub_self]
rwa [Ne, Ideal.Quotient.eq_zero_iff_mem]
· rw [add_sub_cancel]
use β • x
rw [IsScalarTower.algebraMap_eq S Sₚ (Sₚ ⧸ pSₚ), Ideal.Quotient.algebraMap_eq,
RingHom.comp_apply, ← sub_eq_zero, ← map_sub, Ideal.Quotient.eq_zero_iff_mem]
rw [h, IsLocalization.mem_map_algebraMap_iff
(Algebra.algebraMapSubmonoid S p.primeCompl) Sₚ]
refine ⟨⟨⟨γ • x, ?_⟩, s⟩, ?_⟩
· rw [Algebra.smul_def]
apply Ideal.mul_mem_right
exact Ideal.mem_map_of_mem _ hγ
simp only
rw [mul_comm, mul_sub, IsLocalization.mul_mk'_eq_mk'_of_mul,
IsLocalization.mk'_mul_cancel_left, ← map_mul, ← e, ← Algebra.smul_def, smul_smul,
hβ, ← map_sub, add_smul, one_smul, add_comm x, add_sub_cancel_right] | def | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict",
"Mathlib.RingTheory.LocalRing.Quotient"
] | Mathlib/RingTheory/Trace/Quotient.lean | quotMapEquivQuotMapMaximalIdealOfIsLocalization | The isomorphism `S ⧸ pS ≃+* Sₚ ⧸ pSₚ`. |
trace_quotient_eq_trace_localization_quotient (x) :
Algebra.trace (R ⧸ p) (S ⧸ pS) (Ideal.Quotient.mk pS x) =
(equivQuotMaximalIdealOfIsLocalization p Rₚ).symm
(Algebra.trace (Rₚ ⧸ maximalIdeal Rₚ) (Sₚ ⧸ pSₚ) (algebraMap S _ x)) := by
have : IsScalarTower R (Rₚ ⧸ maximalIdeal Rₚ) (Sₚ ⧸ pSₚ) := by
apply IsScalarTower.of_algebraMap_eq'
rw [IsScalarTower.algebraMap_eq R Rₚ (Rₚ ⧸ _), IsScalarTower.algebraMap_eq R Rₚ (Sₚ ⧸ _),
← RingHom.comp_assoc, ← IsScalarTower.algebraMap_eq Rₚ]
rw [Algebra.trace_eq_of_equiv_equiv (equivQuotMaximalIdealOfIsLocalization p Rₚ)
(quotMapEquivQuotMapMaximalIdealOfIsLocalization S p Rₚ Sₚ)]
· congr
· ext x
simp only [equivQuotMaximalIdealOfIsLocalization, RingHom.quotientKerEquivOfSurjective,
RingEquiv.coe_ringHom_trans, RingHom.coe_comp, RingHom.coe_coe, Function.comp_apply,
Ideal.quotEquivOfEq_mk, RingHom.quotientKerEquivOfRightInverse.apply, RingHom.kerLift_mk,
quotMapEquivQuotMapMaximalIdealOfIsLocalization,
Ideal.Quotient.algebraMap_quotient_map_quotient]
rw [← IsScalarTower.algebraMap_apply, ← IsScalarTower.algebraMap_apply]
open nonZeroDivisors in | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict",
"Mathlib.RingTheory.LocalRing.Quotient"
] | Mathlib/RingTheory/Trace/Quotient.lean | trace_quotient_eq_trace_localization_quotient | null |
Algebra.trace_quotient_eq_of_isDedekindDomain (x) [IsDedekindDomain R] [IsDomain S]
[NoZeroSMulDivisors R S] [Module.Finite R S] [IsIntegrallyClosed S] :
Algebra.trace (R ⧸ p) (S ⧸ pS) (Ideal.Quotient.mk pS x) =
Ideal.Quotient.mk p (Algebra.intTrace R S x) := by
let Rₚ := Localization.AtPrime p
let Sₚ := Localization (Algebra.algebraMapSubmonoid S p.primeCompl)
letI : Algebra Rₚ Sₚ := localizationAlgebra p.primeCompl S
haveI : IsScalarTower R Rₚ Sₚ := IsScalarTower.of_algebraMap_eq'
(by rw [RingHom.algebraMap_toAlgebra, IsLocalization.map_comp, ← IsScalarTower.algebraMap_eq])
haveI : IsLocalization (Submonoid.map (algebraMap R S) (Ideal.primeCompl p)) Sₚ :=
inferInstanceAs (IsLocalization (Algebra.algebraMapSubmonoid S p.primeCompl) Sₚ)
have e : Algebra.algebraMapSubmonoid S p.primeCompl ≤ S⁰ :=
Submonoid.map_le_of_le_comap _ <| p.primeCompl_le_nonZeroDivisors.trans
(nonZeroDivisors_le_comap_nonZeroDivisors_of_injective _
(FaithfulSMul.algebraMap_injective _ _))
haveI : IsDomain Sₚ := IsLocalization.isDomain_of_le_nonZeroDivisors _ e
haveI : NoZeroSMulDivisors Rₚ Sₚ := by
rw [NoZeroSMulDivisors.iff_algebraMap_injective, RingHom.injective_iff_ker_eq_bot,
RingHom.ker_eq_bot_iff_eq_zero]
simp
haveI : Module.Finite Rₚ Sₚ := .of_isLocalization R S p.primeCompl
haveI : IsIntegrallyClosed Sₚ := isIntegrallyClosed_of_isLocalization _ _ e
have : IsPrincipalIdealRing Rₚ := by
by_cases hp : p = ⊥
· infer_instance
· have := (IsDedekindDomain.isDedekindDomainDvr R).2 p hp inferInstance
infer_instance
haveI : Module.Free Rₚ Sₚ := Module.free_of_finite_type_torsion_free'
apply (equivQuotMaximalIdealOfIsLocalization p Rₚ).injective
rw [trace_quotient_eq_trace_localization_quotient S p Rₚ Sₚ, IsScalarTower.algebraMap_eq S Sₚ,
RingHom.comp_apply, Ideal.Quotient.algebraMap_eq, Algebra.trace_quotient_mk,
RingEquiv.apply_symm_apply, ← Algebra.intTrace_eq_trace,
← Algebra.intTrace_eq_of_isLocalization R S p.primeCompl (Aₘ := Rₚ) (Bₘ := Sₚ) x,
← Ideal.Quotient.algebraMap_eq, ← IsScalarTower.algebraMap_apply]
simp only [equivQuotMaximalIdealOfIsLocalization, RingHom.quotientKerEquivOfSurjective,
RingEquiv.coe_trans, Function.comp_apply, Ideal.quotEquivOfEq_mk,
RingHom.quotientKerEquivOfRightInverse.apply, RingHom.kerLift_mk] | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.Dvr",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict",
"Mathlib.RingTheory.LocalRing.Quotient"
] | Mathlib/RingTheory/Trace/Quotient.lean | Algebra.trace_quotient_eq_of_isDedekindDomain | The trace map on `B → A` coincides with the trace map on `B⧸pB → A⧸p`. |
TwoSidedIdeal (R : Type*) [NonUnitalNonAssocRing R] where
/-- every two-sided-ideal is induced by a congruence relation on the ring. -/
ringCon : RingCon R | structure | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | TwoSidedIdeal | A two-sided ideal of a ring `R` is a subset of `R` that contains `0` and is closed under addition,
negation, and absorbs multiplication on both sides. |
setLike : SetLike (TwoSidedIdeal R) R where
coe t := {r | t.ringCon r 0}
coe_injective' := by
rintro ⟨t₁⟩ ⟨t₂⟩ (h : {x | _} = {x | _})
congr 1
refine RingCon.ext fun a b ↦ ⟨fun H ↦ ?_, fun H ↦ ?_⟩
· have H' : a - b ∈ {x | t₁ x 0} := sub_self b ▸ t₁.sub H (t₁.refl b)
rw [h] at H'
convert t₂.add H' (t₂.refl b) using 1 <;> abel
· have H' : a - b ∈ {x | t₂ x 0} := sub_self b ▸ t₂.sub H (t₂.refl b)
rw [← h] at H'
convert t₁.add H' (t₁.refl b) using 1 <;> abel | instance | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | setLike | null |
mem_iff (x : R) : x ∈ I ↔ I.ringCon x 0 := Iff.rfl
@[simp] | lemma | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | mem_iff | null |
mem_mk {x : R} {c : RingCon R} : x ∈ mk c ↔ c x 0 := Iff.rfl
@[simp, norm_cast] | lemma | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | mem_mk | null |
coe_mk {c : RingCon R} : (mk c : Set R) = {x | c x 0} := rfl | lemma | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | coe_mk | null |
rel_iff (x y : R) : I.ringCon x y ↔ x - y ∈ I := by
rw [mem_iff]
constructor
· intro h; convert I.ringCon.sub h (I.ringCon.refl y); abel
· intro h; convert I.ringCon.add h (I.ringCon.refl y) <;> abel | lemma | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | rel_iff | null |
@[simps]
coeOrderEmbedding : TwoSidedIdeal R ↪o Set R where
toFun := SetLike.coe
inj' := SetLike.coe_injective
map_rel_iff' {I J} := ⟨fun (h : (I : Set R) ⊆ (J : Set R)) _ h' ↦ h h', fun h _ h' ↦ h h'⟩ | def | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | coeOrderEmbedding | the coercion from two-sided-ideals to sets is an order embedding |
le_iff {I J : TwoSidedIdeal R} : I ≤ J ↔ (I : Set R) ⊆ (J : Set R) := Iff.rfl | lemma | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | le_iff | null |
@[simps apply symm_apply]
orderIsoRingCon : TwoSidedIdeal R ≃o RingCon R where
toFun := TwoSidedIdeal.ringCon
invFun := .mk
map_rel_iff' {I J} := Iff.symm <| le_iff.trans ⟨fun h x y r => by rw [rel_iff] at r ⊢; exact h r,
fun h x hx => by rw [SetLike.mem_coe, mem_iff] at hx ⊢; exact h hx⟩ | def | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | orderIsoRingCon | Two-sided-ideals corresponds to congruence relations on a ring. |
ringCon_injective : Function.Injective (TwoSidedIdeal.ringCon (R := R)) := by
rintro ⟨x⟩ ⟨y⟩ rfl; rfl | lemma | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | ringCon_injective | null |
ringCon_le_iff {I J : TwoSidedIdeal R} : I ≤ J ↔ I.ringCon ≤ J.ringCon :=
orderIsoRingCon.map_rel_iff.symm
@[ext] | lemma | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | ringCon_le_iff | null |
ext {I J : TwoSidedIdeal R} (h : ∀ x, x ∈ I ↔ x ∈ J) : I = J :=
coeOrderEmbedding.injective (Set.ext h) | lemma | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | ext | null |
lt_iff (I J : TwoSidedIdeal R) : I < J ↔ (I : Set R) ⊂ (J : Set R) := by
rw [lt_iff_le_and_ne, Set.ssubset_iff_subset_ne, le_iff]
simp | lemma | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | lt_iff | null |
zero_mem : 0 ∈ I := I.ringCon.refl 0 | lemma | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | zero_mem | null |
add_mem {x y} (hx : x ∈ I) (hy : y ∈ I) : x + y ∈ I := by simpa using I.ringCon.add hx hy | lemma | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | add_mem | null |
neg_mem {x} (hx : x ∈ I) : -x ∈ I := by simpa using I.ringCon.neg hx | lemma | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | neg_mem | null |
sub_mem {x y} (hx : x ∈ I) (hy : y ∈ I) : x - y ∈ I := _root_.sub_mem hx hy | lemma | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | sub_mem | null |
mul_mem_left (x y) (hy : y ∈ I) : x * y ∈ I := by
simpa using I.ringCon.mul (I.ringCon.refl x) hy | lemma | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | mul_mem_left | null |
mul_mem_right (x y) (hx : x ∈ I) : x * y ∈ I := by
simpa using I.ringCon.mul hx (I.ringCon.refl y) | lemma | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | mul_mem_right | null |
nsmul_mem {x} (n : ℕ) (hx : x ∈ I) : n • x ∈ I := _root_.nsmul_mem hx _ | lemma | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | nsmul_mem | null |
zsmul_mem {x} (n : ℤ) (hx : x ∈ I) : n • x ∈ I := _root_.zsmul_mem hx _ | lemma | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | zsmul_mem | null |
mk' (carrier : Set R)
(zero_mem : 0 ∈ carrier)
(add_mem : ∀ {x y}, x ∈ carrier → y ∈ carrier → x + y ∈ carrier)
(neg_mem : ∀ {x}, x ∈ carrier → -x ∈ carrier)
(mul_mem_left : ∀ {x y}, y ∈ carrier → x * y ∈ carrier)
(mul_mem_right : ∀ {x y}, x ∈ carrier → x * y ∈ carrier) : TwoSidedIdeal R where
ringCon :=
{ r := fun x y ↦ x - y ∈ carrier
iseqv :=
{ refl := fun x ↦ by simpa using zero_mem
symm := fun h ↦ by simpa using neg_mem h
trans := fun {x y z} h1 h2 ↦ by
simpa only [show x - z = (x - y) + (y - z) by abel] using add_mem h1 h2 }
mul' := fun {a b c d} (h1 : a - b ∈ carrier) (h2 : c - d ∈ carrier) ↦ show _ ∈ carrier by
rw [show a * c - b * d = a * (c - d) + (a - b) * d by rw [mul_sub, sub_mul]; abel]
exact add_mem (mul_mem_left h2) (mul_mem_right h1)
add' := fun {a b c d} (h1 : a - b ∈ carrier) (h2 : c - d ∈ carrier) ↦ show _ ∈ carrier by
rw [show a + c - (b + d) = (a - b) + (c - d) by abel]
exact add_mem h1 h2 }
@[simp] | def | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | mk' | The "set-theoretic-way" of constructing a two-sided ideal by providing:
- the underlying set `S`;
- a proof that `0 ∈ S`;
- a proof that `x + y ∈ S` if `x ∈ S` and `y ∈ S`;
- a proof that `-x ∈ S` if `x ∈ S`;
- a proof that `x * y ∈ S` if `y ∈ S`;
- a proof that `x * y ∈ S` if `x ∈ S`. |
mem_mk' (carrier : Set R) (zero_mem add_mem neg_mem mul_mem_left mul_mem_right) (x : R) :
x ∈ mk' carrier zero_mem add_mem neg_mem mul_mem_left mul_mem_right ↔ x ∈ carrier := by
rw [mem_iff]
simp [mk']
set_option linter.docPrime false in
@[simp] | lemma | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | mem_mk' | null |
coe_mk' (carrier : Set R) (zero_mem add_mem neg_mem mul_mem_left mul_mem_right) :
(mk' carrier zero_mem add_mem neg_mem mul_mem_left mul_mem_right : Set R) = carrier :=
Set.ext <| mem_mk' carrier zero_mem add_mem neg_mem mul_mem_left mul_mem_right | lemma | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | coe_mk' | null |
addCommGroup : AddCommGroup I :=
Function.Injective.addCommGroup _ Subtype.coe_injective
rfl (fun _ _ ↦ rfl) (fun _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl) | instance | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | addCommGroup | null |
@[simps]
coeAddMonoidHom : I →+ R where
toFun := (↑)
map_zero' := rfl
map_add' _ _ := rfl | def | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | coeAddMonoidHom | The coercion into the ring as a `AddMonoidHom` |
@[simps]
op (I : TwoSidedIdeal R) : TwoSidedIdeal Rᵐᵒᵖ where
ringCon := I.ringCon.op
@[simp] | def | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | op | If `I` is a two-sided ideal of `R`, then `{op x | x ∈ I}` is a two-sided ideal in `Rᵐᵒᵖ`. |
mem_op_iff {I : TwoSidedIdeal R} {x : Rᵐᵒᵖ} : x ∈ I.op ↔ x.unop ∈ I :=
I.ringCon.comm'
@[simp, norm_cast] | lemma | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | mem_op_iff | null |
coe_op {I : TwoSidedIdeal R} : (I.op : Set Rᵐᵒᵖ) = MulOpposite.unop ⁻¹' I :=
Set.ext fun _ => mem_op_iff | lemma | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | coe_op | null |
@[simps]
unop (I : TwoSidedIdeal Rᵐᵒᵖ) : TwoSidedIdeal R where
ringCon := I.ringCon.unop
@[simp] | def | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | unop | If `I` is a two-sided ideal of `Rᵐᵒᵖ`, then `{x.unop | x ∈ I}` is a two-sided ideal in `R`. |
mem_unop_iff {I : TwoSidedIdeal Rᵐᵒᵖ} {x : R} : x ∈ I.unop ↔ MulOpposite.op x ∈ I :=
I.ringCon.comm'
@[simp, norm_cast] | lemma | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | mem_unop_iff | null |
coe_unop {I : TwoSidedIdeal Rᵐᵒᵖ} : (I.unop : Set R) = MulOpposite.op ⁻¹' I :=
Set.ext fun _ => mem_unop_iff | lemma | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | coe_unop | null |
@[simps]
opOrderIso : TwoSidedIdeal R ≃o TwoSidedIdeal Rᵐᵒᵖ where
toFun := op
invFun := unop
map_rel_iff' {I' J'} := by simpa [ringCon_le_iff] using RingCon.opOrderIso.map_rel_iff | def | RingTheory | [
"Mathlib.Tactic.Abel",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.GroupTheory.GroupAction.SubMulAction",
"Mathlib.RingTheory.Congruence.Opposite"
] | Mathlib/RingTheory/TwoSidedIdeal/Basic.lean | opOrderIso | Two-sided-ideals of `A` and that of `Aᵒᵖ` corresponds bijectively to each other. |
listSum_mem {ι : Type*} (l : List ι) (f : ι → R) (hl : ∀ x ∈ l, f x ∈ I) :
(l.map f).sum ∈ I := by
rw [mem_iff, ← List.sum_map_zero]
exact I.ringCon.listSum l hl | lemma | RingTheory | [
"Mathlib.RingTheory.Congruence.BigOperators",
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/BigOperators.lean | listSum_mem | null |
multisetSum_mem {ι : Type*} (s : Multiset ι) (f : ι → R) (hs : ∀ x ∈ s, f x ∈ I) :
(s.map f).sum ∈ I := by
rw [mem_iff, ← Multiset.sum_map_zero]
exact I.ringCon.multisetSum s hs | lemma | RingTheory | [
"Mathlib.RingTheory.Congruence.BigOperators",
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/BigOperators.lean | multisetSum_mem | null |
finsetSum_mem {ι : Type*} (s : Finset ι) (f : ι → R) (hs : ∀ x ∈ s, f x ∈ I) :
s.sum f ∈ I := by
rw [mem_iff, ← Finset.sum_const_zero]
exact I.ringCon.finsetSum s hs | lemma | RingTheory | [
"Mathlib.RingTheory.Congruence.BigOperators",
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/BigOperators.lean | finsetSum_mem | null |
listProd_mem {ι : Type*} (l : List ι) (f : ι → R) (hl : ∃ x ∈ l, f x ∈ I) :
(l.map f).prod ∈ I := by
induction l with
| nil => simp only [List.not_mem_nil, false_and, exists_false] at hl
| cons x l ih =>
simp only [List.mem_cons, exists_eq_or_imp] at hl
rcases hl with h | hal
· simpa only [List.map_cons, List.prod_cons] using I.mul_mem_right _ _ h
· simpa only [List.map_cons, List.prod_cons] using I.mul_mem_left _ _ <| ih hal | lemma | RingTheory | [
"Mathlib.RingTheory.Congruence.BigOperators",
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/BigOperators.lean | listProd_mem | null |
multiSetProd_mem {ι : Type*} (s : Multiset ι) (f : ι → R) (hs : ∃ x ∈ s, f x ∈ I) :
(s.map f).prod ∈ I := by
rcases s
simpa using listProd_mem (hl := hs) | lemma | RingTheory | [
"Mathlib.RingTheory.Congruence.BigOperators",
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/BigOperators.lean | multiSetProd_mem | null |
finsetProd_mem {ι : Type*} (s : Finset ι) (f : ι → R) (hs : ∃ x ∈ s, f x ∈ I) :
s.prod f ∈ I := by
rcases s
simpa using multiSetProd_mem (hs := hs) | lemma | RingTheory | [
"Mathlib.RingTheory.Congruence.BigOperators",
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/BigOperators.lean | finsetProd_mem | null |
ker : TwoSidedIdeal R :=
.mk
{ r := fun x y ↦ f x = f y
iseqv := by constructor <;> aesop
mul' := by intro; simp_all
add' := by intro; simp_all }
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Basic",
"Mathlib.RingTheory.TwoSidedIdeal.Lattice"
] | Mathlib/RingTheory/TwoSidedIdeal/Kernel.lean | ker | The kernel of a ring homomorphism, as a two-sided ideal. |
ker_ringCon {x y : R} : (ker f).ringCon x y ↔ f x = f y := Iff.rfl | lemma | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Basic",
"Mathlib.RingTheory.TwoSidedIdeal.Lattice"
] | Mathlib/RingTheory/TwoSidedIdeal/Kernel.lean | ker_ringCon | null |
mem_ker {x : R} : x ∈ ker f ↔ f x = 0 := by
rw [mem_iff, ker_ringCon, map_zero] | lemma | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Basic",
"Mathlib.RingTheory.TwoSidedIdeal.Lattice"
] | Mathlib/RingTheory/TwoSidedIdeal/Kernel.lean | mem_ker | null |
ker_eq_bot : ker f = ⊥ ↔ Function.Injective f := by
fconstructor
· intro h x y hxy
simpa [h, rel_iff, mem_bot, sub_eq_zero] using show (ker f).ringCon x y from hxy
· exact fun h ↦ eq_bot_iff.2 fun x hx => h hx | lemma | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Basic",
"Mathlib.RingTheory.TwoSidedIdeal.Lattice"
] | Mathlib/RingTheory/TwoSidedIdeal/Kernel.lean | ker_eq_bot | null |
@[simp]
ker_ringCon_mk' (I : TwoSidedIdeal R) : ker I.ringCon.mk' = I :=
le_antisymm
(fun _ h => by simpa using I.rel_iff _ _ |>.1 (Quotient.eq'.1 h))
(fun _ h => Quotient.sound' <| I.rel_iff _ _ |>.2 (by simpa using h)) | lemma | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Basic",
"Mathlib.RingTheory.TwoSidedIdeal.Lattice"
] | Mathlib/RingTheory/TwoSidedIdeal/Kernel.lean | ker_ringCon_mk' | The kernel of the ring homomorphism `R → R⧸I` is `I`. |
sup_ringCon (I J : TwoSidedIdeal R) : (I ⊔ J).ringCon = I.ringCon ⊔ J.ringCon := rfl | lemma | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Lattice.lean | sup_ringCon | null |
mem_sup_left {I J : TwoSidedIdeal R} {x : R} (h : x ∈ I) :
x ∈ I ⊔ J :=
(show I ≤ I ⊔ J from le_sup_left) h | lemma | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Lattice.lean | mem_sup_left | null |
mem_sup_right {I J : TwoSidedIdeal R} {x : R} (h : x ∈ J) :
x ∈ I ⊔ J :=
(show J ≤ I ⊔ J from le_sup_right) h | lemma | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Lattice.lean | mem_sup_right | null |
mem_sup {I J : TwoSidedIdeal R} {x : R} :
x ∈ I ⊔ J ↔ ∃ y ∈ I, ∃ z ∈ J, y + z = x := by
constructor
· let s : TwoSidedIdeal R := .mk'
{x | ∃ y ∈ I, ∃ z ∈ J, y + z = x}
⟨0, ⟨zero_mem _, ⟨0, ⟨zero_mem _, zero_add _⟩⟩⟩⟩
(by rintro _ _ ⟨x, ⟨hx, ⟨y, ⟨hy, rfl⟩⟩⟩⟩ ⟨a, ⟨ha, ⟨b, ⟨hb, rfl⟩⟩⟩⟩;
exact ⟨x + a, ⟨add_mem _ hx ha, ⟨y + b, ⟨add_mem _ hy hb, by abel⟩⟩⟩⟩)
(by rintro _ ⟨x, ⟨hx, ⟨y, ⟨hy, rfl⟩⟩⟩⟩
exact ⟨-x, ⟨neg_mem _ hx, ⟨-y, ⟨neg_mem _ hy, by abel⟩⟩⟩⟩)
(by rintro r _ ⟨x, ⟨hx, ⟨y, ⟨hy, rfl⟩⟩⟩⟩
exact ⟨_, ⟨mul_mem_left _ _ _ hx, ⟨_, ⟨mul_mem_left _ _ _ hy, mul_add _ _ _ |>.symm⟩⟩⟩⟩)
(by rintro r _ ⟨x, ⟨hx, ⟨y, ⟨hy, rfl⟩⟩⟩⟩
exact ⟨_, ⟨mul_mem_right _ _ _ hx, ⟨_, ⟨mul_mem_right _ _ _ hy, add_mul _ _ _ |>.symm⟩⟩⟩⟩)
suffices (I.ringCon ⊔ J.ringCon) ≤ s.ringCon by
intro h; convert this h; rw [rel_iff, sub_zero, mem_mk']; rfl
refine sup_le (fun x y h => ?_) (fun x y h => ?_) <;> rw [rel_iff] at h ⊢ <;> rw [mem_mk']
exacts [⟨_, ⟨h, ⟨0, ⟨zero_mem _, add_zero _⟩⟩⟩⟩, ⟨0, ⟨zero_mem _, ⟨_, ⟨h, zero_add _⟩⟩⟩⟩]
· rintro ⟨y, ⟨hy, ⟨z, ⟨hz, rfl⟩⟩⟩⟩; exact add_mem _ (mem_sup_left hy) (mem_sup_right hz) | lemma | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Lattice.lean | mem_sup | null |
inf_ringCon (I J : TwoSidedIdeal R) : (I ⊓ J).ringCon = I.ringCon ⊓ J.ringCon := rfl | lemma | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Lattice.lean | inf_ringCon | null |
mem_inf {I J : TwoSidedIdeal R} {x : R} :
x ∈ I ⊓ J ↔ x ∈ I ∧ x ∈ J :=
Iff.rfl | lemma | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Lattice.lean | mem_inf | null |
sSup_ringCon (S : Set (TwoSidedIdeal R)) :
(sSup S).ringCon = sSup (TwoSidedIdeal.ringCon '' S) := rfl | lemma | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Lattice.lean | sSup_ringCon | null |
iSup_ringCon {ι : Type*} (I : ι → TwoSidedIdeal R) :
(⨆ i, I i).ringCon = ⨆ i, (I i).ringCon := by
simp only [iSup, sSup_ringCon]; congr; ext; simp | lemma | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Lattice.lean | iSup_ringCon | null |
sInf_ringCon (S : Set (TwoSidedIdeal R)) :
(sInf S).ringCon = sInf (TwoSidedIdeal.ringCon '' S) := rfl | lemma | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Lattice.lean | sInf_ringCon | null |
iInf_ringCon {ι : Type*} (I : ι → TwoSidedIdeal R) :
(⨅ i, I i).ringCon = ⨅ i, (I i).ringCon := by
simp only [iInf, sInf_ringCon]; congr!; ext; simp | lemma | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Lattice.lean | iInf_ringCon | null |
mem_iInf {ι : Type*} {I : ι → TwoSidedIdeal R} {x : R} :
x ∈ iInf I ↔ ∀ i, x ∈ I i :=
show (∀ _, _) ↔ _ by simp [mem_iff] | lemma | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Lattice.lean | mem_iInf | null |
mem_sInf {S : Set (TwoSidedIdeal R)} {x : R} :
x ∈ sInf S ↔ ∀ I ∈ S, x ∈ I :=
show (∀ _, _) ↔ _ by simp [mem_iff] | lemma | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Lattice.lean | mem_sInf | null |
top_ringCon : (⊤ : TwoSidedIdeal R).ringCon = ⊤ := rfl
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Lattice.lean | top_ringCon | null |
mem_top {x : R} : x ∈ (⊤: TwoSidedIdeal R) := trivial | lemma | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Lattice.lean | mem_top | null |
bot_ringCon : (⊥ : TwoSidedIdeal R).ringCon = ⊥ := rfl
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Lattice.lean | bot_ringCon | null |
mem_bot {x : R} : x ∈ (⊥ : TwoSidedIdeal R) ↔ x = 0 :=
Iff.rfl | lemma | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Lattice.lean | mem_bot | null |
@[simp]
coe_bot : ((⊥ : TwoSidedIdeal R) : Set R) = {0} := rfl
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Lattice.lean | coe_bot | null |
coe_top : ((⊤ : TwoSidedIdeal R) : Set R) = Set.univ := rfl | lemma | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Lattice.lean | coe_top | null |
one_mem_iff {R : Type*} [NonAssocRing R] (I : TwoSidedIdeal R) :
(1 : R) ∈ I ↔ I = ⊤ :=
⟨fun h => eq_top_iff.2 fun x _ => by simpa using I.mul_mem_left x _ h, fun h ↦ h.symm ▸ trivial⟩
alias ⟨eq_top, one_mem⟩ := one_mem_iff | lemma | RingTheory | [
"Mathlib.RingTheory.TwoSidedIdeal.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Lattice.lean | one_mem_iff | null |
span (s : Set R) : TwoSidedIdeal R :=
{ ringCon := ringConGen (fun a b ↦ a - b ∈ s) } | abbrev | RingTheory | [
"Mathlib.Algebra.Group.Subgroup.Map",
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Algebra.Module.Submodule.Lattice",
"Mathlib.RingTheory.Congruence.Opposite",
"Mathlib.RingTheory.Ideal.Defs",
"Mathlib.RingTheory.TwoSidedIdeal.Lattice",
"Mathlib.Algebra.Group.Pointwise.Set.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Operations.lean | span | The smallest two-sided ideal containing a set. |
subset_span {s : Set R} : s ⊆ (span s : Set R) := by
intro x hx
rw [SetLike.mem_coe, mem_iff]
exact RingConGen.Rel.of _ _ (by simpa using hx) | lemma | RingTheory | [
"Mathlib.Algebra.Group.Subgroup.Map",
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Algebra.Module.Submodule.Lattice",
"Mathlib.RingTheory.Congruence.Opposite",
"Mathlib.RingTheory.Ideal.Defs",
"Mathlib.RingTheory.TwoSidedIdeal.Lattice",
"Mathlib.Algebra.Group.Pointwise.Set.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Operations.lean | subset_span | null |
mem_span_iff {s : Set R} {x} :
x ∈ span s ↔ ∀ (I : TwoSidedIdeal R), s ⊆ I → x ∈ I := by
refine ⟨?_, fun h => h _ subset_span⟩
delta span
rw [RingCon.ringConGen_eq]
intro h I hI
refine sInf_le (α := RingCon R) ?_ h
intro x y hxy
specialize hI hxy
rwa [SetLike.mem_coe, ← rel_iff] at hI | lemma | RingTheory | [
"Mathlib.Algebra.Group.Subgroup.Map",
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Algebra.Module.Submodule.Lattice",
"Mathlib.RingTheory.Congruence.Opposite",
"Mathlib.RingTheory.Ideal.Defs",
"Mathlib.RingTheory.TwoSidedIdeal.Lattice",
"Mathlib.Algebra.Group.Pointwise.Set.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Operations.lean | mem_span_iff | null |
span_mono {s t : Set R} (h : s ⊆ t) : span s ≤ span t := by
intro x hx
rw [mem_span_iff] at hx ⊢
exact fun I hI => hx I <| h.trans hI | lemma | RingTheory | [
"Mathlib.Algebra.Group.Subgroup.Map",
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Algebra.Module.Submodule.Lattice",
"Mathlib.RingTheory.Congruence.Opposite",
"Mathlib.RingTheory.Ideal.Defs",
"Mathlib.RingTheory.TwoSidedIdeal.Lattice",
"Mathlib.Algebra.Group.Pointwise.Set.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Operations.lean | span_mono | null |
span_le {s : Set R} {I : TwoSidedIdeal R} : span s ≤ I ↔ s ⊆ I := by
rw [TwoSidedIdeal.ringCon_le_iff, RingCon.gi _ |>.gc]
exact ⟨fun h x hx ↦ by aesop, fun h x y hxy ↦ (rel_iff I x y).mpr (h hxy)⟩ | lemma | RingTheory | [
"Mathlib.Algebra.Group.Subgroup.Map",
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Algebra.Module.Submodule.Lattice",
"Mathlib.RingTheory.Congruence.Opposite",
"Mathlib.RingTheory.Ideal.Defs",
"Mathlib.RingTheory.TwoSidedIdeal.Lattice",
"Mathlib.Algebra.Group.Pointwise.Set.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Operations.lean | span_le | null |
@[elab_as_elim]
span_induction {s : Set R}
{p : (x : R) → x ∈ TwoSidedIdeal.span s → Prop}
(mem : ∀ (x) (h : x ∈ s), p x (subset_span h))
(zero : p 0 (zero_mem _))
(add : ∀ x y hx hy, p x hx → p y hy → p (x + y) (add_mem _ hx hy))
(neg : ∀ x hx, p x hx → p (-x) (neg_mem _ hx))
(left_absorb : ∀ a x hx, p x hx → p (a * x) (mul_mem_left _ _ _ hx))
(right_absorb : ∀ b x hx, p x hx → p (x * b) (mul_mem_right _ _ _ hx))
{x : R} (hx : x ∈ span s) : p x hx :=
let J : TwoSidedIdeal R := .mk'
{x | ∃ hx, p x hx}
⟨zero_mem _, zero⟩
(fun ⟨hx1, hx2⟩ ⟨hy1, hy2⟩ ↦ ⟨add_mem _ hx1 hy1, add _ _ hx1 hy1 hx2 hy2⟩)
(fun ⟨hx1, hx2⟩ ↦ ⟨neg_mem _ hx1, neg _ hx1 hx2⟩)
(fun {x' y'} ⟨hy1, hy2⟩ ↦ ⟨mul_mem_left _ _ _ hy1, left_absorb _ _ _ hy2⟩)
(fun {x' y'} ⟨hx1, hx2⟩ ↦ ⟨mul_mem_right _ _ _ hx1, right_absorb _ _ _ hx2⟩)
span_le (s := s) (I := J) |>.2
(fun x hx ↦ ⟨by simpa using (mem_span_iff.2 fun I a ↦ a hx), by simp_all⟩) hx
|>.elim fun _ ↦ by simp | theorem | RingTheory | [
"Mathlib.Algebra.Group.Subgroup.Map",
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Algebra.Module.Submodule.Lattice",
"Mathlib.RingTheory.Congruence.Opposite",
"Mathlib.RingTheory.Ideal.Defs",
"Mathlib.RingTheory.TwoSidedIdeal.Lattice",
"Mathlib.Algebra.Group.Pointwise.Set.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Operations.lean | span_induction | An induction principle for span membership.
If `p` holds for 0 and all elements of `s`,
and is preserved under addition and left and right multiplication,
then `p` holds for all elements of the span of `s`. |
map (I : TwoSidedIdeal R) : TwoSidedIdeal S :=
span (f '' I) | def | RingTheory | [
"Mathlib.Algebra.Group.Subgroup.Map",
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Algebra.Module.Submodule.Lattice",
"Mathlib.RingTheory.Congruence.Opposite",
"Mathlib.RingTheory.Ideal.Defs",
"Mathlib.RingTheory.TwoSidedIdeal.Lattice",
"Mathlib.Algebra.Group.Pointwise.Set.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Operations.lean | map | Pushout of a two-sided ideal. Defined as the span of the image of a two-sided ideal under a ring
homomorphism. |
map_mono {I J : TwoSidedIdeal R} (h : I ≤ J) :
map f I ≤ map f J :=
span_mono <| Set.image_mono h
variable [NonUnitalRingHomClass F R S] | lemma | RingTheory | [
"Mathlib.Algebra.Group.Subgroup.Map",
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Algebra.Module.Submodule.Lattice",
"Mathlib.RingTheory.Congruence.Opposite",
"Mathlib.RingTheory.Ideal.Defs",
"Mathlib.RingTheory.TwoSidedIdeal.Lattice",
"Mathlib.Algebra.Group.Pointwise.Set.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Operations.lean | map_mono | null |
comap : TwoSidedIdeal S →o TwoSidedIdeal R where
toFun I := ⟨I.ringCon.comap f⟩
monotone' := by
intro I J h
rw [le_iff] at h
intro x
specialize @h (f x)
simpa [mem_iff, RingCon.comap] | def | RingTheory | [
"Mathlib.Algebra.Group.Subgroup.Map",
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Algebra.Module.Submodule.Lattice",
"Mathlib.RingTheory.Congruence.Opposite",
"Mathlib.RingTheory.Ideal.Defs",
"Mathlib.RingTheory.TwoSidedIdeal.Lattice",
"Mathlib.Algebra.Group.Pointwise.Set.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Operations.lean | comap | Preimage of a two-sided ideal, as a two-sided ideal. |
comap_le_comap {I J : TwoSidedIdeal S} (h : I ≤ J) :
comap f I ≤ comap f J :=
(comap f).monotone h | lemma | RingTheory | [
"Mathlib.Algebra.Group.Subgroup.Map",
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Algebra.Module.Submodule.Lattice",
"Mathlib.RingTheory.Congruence.Opposite",
"Mathlib.RingTheory.Ideal.Defs",
"Mathlib.RingTheory.TwoSidedIdeal.Lattice",
"Mathlib.Algebra.Group.Pointwise.Set.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Operations.lean | comap_le_comap | null |
mem_comap {I : TwoSidedIdeal S} {x : R} :
x ∈ I.comap f ↔ f x ∈ I := by
simp [comap, RingCon.comap, mem_iff] | lemma | RingTheory | [
"Mathlib.Algebra.Group.Subgroup.Map",
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Algebra.Module.Submodule.Lattice",
"Mathlib.RingTheory.Congruence.Opposite",
"Mathlib.RingTheory.Ideal.Defs",
"Mathlib.RingTheory.TwoSidedIdeal.Lattice",
"Mathlib.Algebra.Group.Pointwise.Set.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Operations.lean | mem_comap | null |
_root_.RingEquiv.mapTwoSidedIdeal (e : R ≃+* S) : TwoSidedIdeal R ≃o TwoSidedIdeal S :=
OrderIso.ofHomInv (comap e.symm) (comap e) (by ext; simp [mem_comap])
(by ext; simp [mem_comap]) | def | RingTheory | [
"Mathlib.Algebra.Group.Subgroup.Map",
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Algebra.Module.Submodule.Lattice",
"Mathlib.RingTheory.Congruence.Opposite",
"Mathlib.RingTheory.Ideal.Defs",
"Mathlib.RingTheory.TwoSidedIdeal.Lattice",
"Mathlib.Algebra.Group.Pointwise.Set.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Operations.lean | _root_.RingEquiv.mapTwoSidedIdeal | If `R` and `S` are isomorphic as rings, then two-sided ideals of `R` and two-sided ideals of `S` are
order isomorphic. |
_root_.RingEquiv.mapTwoSidedIdeal_apply (e : R ≃+* S) (I : TwoSidedIdeal R) :
e.mapTwoSidedIdeal I = I.comap e.symm := rfl | lemma | RingTheory | [
"Mathlib.Algebra.Group.Subgroup.Map",
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Algebra.Module.Submodule.Lattice",
"Mathlib.RingTheory.Congruence.Opposite",
"Mathlib.RingTheory.Ideal.Defs",
"Mathlib.RingTheory.TwoSidedIdeal.Lattice",
"Mathlib.Algebra.Group.Pointwise.Set.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Operations.lean | _root_.RingEquiv.mapTwoSidedIdeal_apply | null |
_root_.RingEquiv.mapTwoSidedIdeal_symm (e : R ≃+* S) :
e.mapTwoSidedIdeal.symm = e.symm.mapTwoSidedIdeal := rfl | lemma | RingTheory | [
"Mathlib.Algebra.Group.Subgroup.Map",
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Algebra.Module.Submodule.Lattice",
"Mathlib.RingTheory.Congruence.Opposite",
"Mathlib.RingTheory.Ideal.Defs",
"Mathlib.RingTheory.TwoSidedIdeal.Lattice",
"Mathlib.Algebra.Group.Pointwise.Set.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Operations.lean | _root_.RingEquiv.mapTwoSidedIdeal_symm | null |
comap_comap (I : TwoSidedIdeal T) (f : R →+* S) (g : S →+* T) :
(I.comap g).comap f = I.comap (g.comp f) := by
ext; simp [mem_comap] | lemma | RingTheory | [
"Mathlib.Algebra.Group.Subgroup.Map",
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Algebra.Module.Submodule.Lattice",
"Mathlib.RingTheory.Congruence.Opposite",
"Mathlib.RingTheory.Ideal.Defs",
"Mathlib.RingTheory.TwoSidedIdeal.Lattice",
"Mathlib.Algebra.Group.Pointwise.Set.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Operations.lean | comap_comap | null |
mem_span_iff_mem_addSubgroup_closure_absorbing {s : Set R}
(h_left : ∀ x y, y ∈ s → x * y ∈ s) (h_right : ∀ y x, y ∈ s → y * x ∈ s) {z : R} :
z ∈ span s ↔ z ∈ closure s := by
have h_left' {x y} (hy : y ∈ closure s) : x * y ∈ closure s := by
have := (AddMonoidHom.mulLeft x).map_closure s ▸ mem_map_of_mem _ hy
refine closure_mono ?_ this
rintro - ⟨y, hy, rfl⟩
exact h_left x y hy
have h_right' {y x} (hy : y ∈ closure s) : y * x ∈ closure s := by
have := (AddMonoidHom.mulRight x).map_closure s ▸ mem_map_of_mem _ hy
refine closure_mono ?_ this
rintro - ⟨y, hy, rfl⟩
exact h_right y x hy
let I : TwoSidedIdeal R := .mk' (closure s) (AddSubgroup.zero_mem _)
(AddSubgroup.add_mem _) (AddSubgroup.neg_mem _) h_left' h_right'
suffices z ∈ span s ↔ z ∈ I by simpa only [I, mem_mk', SetLike.mem_coe]
rw [mem_span_iff]
refine ⟨fun h ↦ h I fun x hx ↦ ?mem_closure_of_forall, fun hz J hJ ↦ ?mem_ideal_of_subset⟩
case mem_closure_of_forall => simpa only [I, SetLike.mem_coe, mem_mk'] using subset_closure hx
/- Conversely, suppose that `z ∈ I` and that `J` is any ideal containing `s`. Then by the
induction principle for `AddSubgroup`, we must also have `z ∈ J`. -/
case mem_ideal_of_subset =>
simp only [I, SetLike.mem_coe, mem_mk'] at hz
induction hz using closure_induction with
| mem x hx => exact hJ hx
| zero => exact zero_mem _
| add x y _ _ hx hy => exact J.add_mem hx hy
| neg x _ hx => exact J.neg_mem hx
open Pointwise Set | lemma | RingTheory | [
"Mathlib.Algebra.Group.Subgroup.Map",
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Algebra.Module.Submodule.Lattice",
"Mathlib.RingTheory.Congruence.Opposite",
"Mathlib.RingTheory.Ideal.Defs",
"Mathlib.RingTheory.TwoSidedIdeal.Lattice",
"Mathlib.Algebra.Group.Pointwise.Set.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Operations.lean | mem_span_iff_mem_addSubgroup_closure_absorbing | If `s : Set R` is absorbing under multiplication, then its `TwoSidedIdeal.span` coincides with
its `AddSubgroup.closure`, as sets. |
set_mul_subset {s : Set R} {I : TwoSidedIdeal R} (h : s ⊆ I) (t : Set R) :
t * s ⊆ I := by
rintro - ⟨r, -, x, hx, rfl⟩
exact mul_mem_left _ _ _ (h hx) | lemma | RingTheory | [
"Mathlib.Algebra.Group.Subgroup.Map",
"Mathlib.Algebra.Module.Opposite",
"Mathlib.Algebra.Module.Submodule.Lattice",
"Mathlib.RingTheory.Congruence.Opposite",
"Mathlib.RingTheory.Ideal.Defs",
"Mathlib.RingTheory.TwoSidedIdeal.Lattice",
"Mathlib.Algebra.Group.Pointwise.Set.Basic"
] | Mathlib/RingTheory/TwoSidedIdeal/Operations.lean | set_mul_subset | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.