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 ⌀ |
|---|---|---|---|---|---|---|
comap_le_map_of_inv_on [RingHomClass F R S] (g : G) (I : Ideal S)
(hf : Set.LeftInvOn g f (f ⁻¹' I)) :
I.comap f ≤ I.map g :=
fun x (hx : f x ∈ I) => hf hx ▸ Ideal.mem_map_of_mem g hx | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_le_map_of_inv_on | null |
map_le_comap_of_inverse [RingHomClass G S R] (g : G) (I : Ideal R)
(h : Function.LeftInverse g f) :
I.map f ≤ I.comap g :=
map_le_comap_of_inv_on _ _ _ <| h.leftInvOn _
variable [RingHomClass F R S] | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_le_comap_of_inverse | The `Ideal` version of `Set.image_subset_preimage_of_inverse`. |
comap_le_map_of_inverse (g : G) (I : Ideal S) (h : Function.LeftInverse g f) :
I.comap f ≤ I.map g :=
comap_le_map_of_inv_on _ _ _ <| h.leftInvOn _ | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_le_map_of_inverse | The `Ideal` version of `Set.preimage_subset_image_of_inverse`. |
IsPrime.comap [hK : K.IsPrime] : (comap f K).IsPrime :=
⟨comap_ne_top _ hK.1, fun {x y} => by simp only [mem_comap, map_mul]; apply hK.2⟩
variable (I J K L) | instance | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | IsPrime.comap | null |
map_top : map f ⊤ = ⊤ :=
(eq_top_iff_one _).2 <| subset_span ⟨1, trivial, map_one f⟩ | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_top | null |
gc_map_comap : GaloisConnection (Ideal.map f) (Ideal.comap f) := fun _ _ =>
Ideal.map_le_iff_le_comap
@[simp] | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | gc_map_comap | null |
comap_id : I.comap (RingHom.id R) = I :=
Ideal.ext fun _ => Iff.rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_id | null |
comap_idₐ {R S : Type*} [CommSemiring R] [Semiring S] [Algebra R S] (I : Ideal S) :
Ideal.comap (AlgHom.id R S) I = I :=
I.comap_id
@[simp] | lemma | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_idₐ | null |
map_id : I.map (RingHom.id R) = I :=
(gc_map_comap (RingHom.id R)).l_unique GaloisConnection.id comap_id
@[simp] | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_id | null |
map_idₐ {R S : Type*} [CommSemiring R] [Semiring S] [Algebra R S] (I : Ideal S) :
Ideal.map (AlgHom.id R S) I = I :=
I.map_id | lemma | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_idₐ | null |
comap_comap {T : Type*} [Semiring T] {I : Ideal T} (f : R →+* S) (g : S →+* T) :
(I.comap g).comap f = I.comap (g.comp f) :=
rfl | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_comap | null |
comap_comapₐ {R A B C : Type*} [CommSemiring R] [Semiring A] [Algebra R A] [Semiring B]
[Algebra R B] [Semiring C] [Algebra R C] {I : Ideal C} (f : A →ₐ[R] B) (g : B →ₐ[R] C) :
(I.comap g).comap f = I.comap (g.comp f) :=
I.comap_comap f.toRingHom g.toRingHom | lemma | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_comapₐ | null |
map_map {T : Type*} [Semiring T] {I : Ideal R} (f : R →+* S) (g : S →+* T) :
(I.map f).map g = I.map (g.comp f) :=
((gc_map_comap f).compose (gc_map_comap g)).l_unique (gc_map_comap (g.comp f)) fun _ =>
comap_comap _ _ | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_map | null |
map_mapₐ {R A B C : Type*} [CommSemiring R] [Semiring A] [Algebra R A] [Semiring B]
[Algebra R B] [Semiring C] [Algebra R C] {I : Ideal A} (f : A →ₐ[R] B) (g : B →ₐ[R] C) :
(I.map f).map g = I.map (g.comp f) :=
I.map_map f.toRingHom g.toRingHom | lemma | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_mapₐ | null |
map_span (f : F) (s : Set R) : map f (span s) = span (f '' s) := by
refine (Submodule.span_eq_of_le _ ?_ ?_).symm
· rintro _ ⟨x, hx, rfl⟩; exact mem_map_of_mem f (subset_span hx)
· rw [map_le_iff_le_comap, span_le, coe_comap, ← Set.image_subset_iff]
exact subset_span
variable {f I J K L} | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_span | null |
map_le_of_le_comap : I ≤ K.comap f → I.map f ≤ K :=
(gc_map_comap f).l_le | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_le_of_le_comap | null |
le_comap_of_map_le : I.map f ≤ K → I ≤ K.comap f :=
(gc_map_comap f).le_u | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | le_comap_of_map_le | null |
le_comap_map : I ≤ (I.map f).comap f :=
(gc_map_comap f).le_u_l _ | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | le_comap_map | null |
map_comap_le : (K.comap f).map f ≤ K :=
(gc_map_comap f).l_u_le _
@[simp] | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_comap_le | null |
comap_top : (⊤ : Ideal S).comap f = ⊤ :=
(gc_map_comap f).u_top
@[simp] | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_top | null |
comap_eq_top_iff {I : Ideal S} : I.comap f = ⊤ ↔ I = ⊤ :=
⟨fun h => I.eq_top_iff_one.mpr (map_one f ▸ mem_comap.mp ((I.comap f).eq_top_iff_one.mp h)),
fun h => by rw [h, comap_top]⟩
@[simp] | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_eq_top_iff | null |
map_bot : (⊥ : Ideal R).map f = ⊥ :=
(gc_map_comap f).l_bot | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_bot | null |
ne_bot_of_map_ne_bot (hI : map f I ≠ ⊥) : I ≠ ⊥ :=
fun h => hI (Eq.mpr (congrArg (fun I ↦ map f I = ⊥) h) map_bot)
variable (f I J K L)
@[simp] | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | ne_bot_of_map_ne_bot | null |
map_comap_map : ((I.map f).comap f).map f = I.map f :=
(gc_map_comap f).l_u_l_eq_l I
@[simp] | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_comap_map | null |
comap_map_comap : ((K.comap f).map f).comap f = K.comap f :=
(gc_map_comap f).u_l_u_eq_u K | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_map_comap | null |
map_sup : (I ⊔ J).map f = I.map f ⊔ J.map f :=
(gc_map_comap f : GaloisConnection (map f) (comap f)).l_sup | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_sup | null |
comap_inf : comap f (K ⊓ L) = comap f K ⊓ comap f L :=
rfl
variable {ι : Sort*} | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_inf | null |
map_iSup (K : ι → Ideal R) : (iSup K).map f = ⨆ i, (K i).map f :=
(gc_map_comap f : GaloisConnection (map f) (comap f)).l_iSup | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_iSup | null |
comap_iInf (K : ι → Ideal S) : (iInf K).comap f = ⨅ i, (K i).comap f :=
(gc_map_comap f : GaloisConnection (map f) (comap f)).u_iInf | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_iInf | null |
map_sSup (s : Set (Ideal R)) : (sSup s).map f = ⨆ I ∈ s, (I : Ideal R).map f :=
(gc_map_comap f : GaloisConnection (map f) (comap f)).l_sSup | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_sSup | null |
comap_sInf (s : Set (Ideal S)) : (sInf s).comap f = ⨅ I ∈ s, (I : Ideal S).comap f :=
(gc_map_comap f : GaloisConnection (map f) (comap f)).u_sInf | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_sInf | null |
comap_sInf' (s : Set (Ideal S)) : (sInf s).comap f = ⨅ I ∈ comap f '' s, I :=
_root_.trans (comap_sInf f s) (by rw [iInf_image]) | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_sInf' | null |
comap_isPrime [H : IsPrime K] : IsPrime (comap f K) :=
H.comap f
variable {I J K L} | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_isPrime | Variant of `Ideal.IsPrime.comap` where ideal is explicit rather than implicit. |
map_inf_le : map f (I ⊓ J) ≤ map f I ⊓ map f J :=
(gc_map_comap f : GaloisConnection (map f) (comap f)).monotone_l.map_inf_le _ _ | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_inf_le | null |
le_comap_sup : comap f K ⊔ comap f L ≤ comap f (K ⊔ L) :=
(gc_map_comap f : GaloisConnection (map f) (comap f)).monotone_u.le_map_sup _ _ | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | le_comap_sup | null |
_root_.element_smul_restrictScalars {R S M}
[CommSemiring R] [CommSemiring S] [Algebra R S] [AddCommMonoid M]
[Module R M] [Module S M] [IsScalarTower R S M] (r : R) (N : Submodule S M) :
(algebraMap R S r • N).restrictScalars R = r • N.restrictScalars R :=
SetLike.coe_injective (congrArg (· '' _) (funext (algebraMap_smul S r))) | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | _root_.element_smul_restrictScalars | null |
smul_restrictScalars {R S M} [CommSemiring R] [CommSemiring S]
[Algebra R S] [AddCommMonoid M] [Module R M] [Module S M]
[IsScalarTower R S M] (I : Ideal R) (N : Submodule S M) :
(I.map (algebraMap R S) • N).restrictScalars R = I • N.restrictScalars R := by
simp_rw [map, Submodule.span_smul_eq, ← Submodule.coe_set_smul,
Submodule.set_smul_eq_iSup, ← element_smul_restrictScalars, iSup_image]
exact map_iSup₂ (Submodule.restrictScalarsLatticeHom R S M) _
@[simp] | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | smul_restrictScalars | null |
smul_top_eq_map {R S : Type*} [CommSemiring R] [CommSemiring S] [Algebra R S]
(I : Ideal R) : I • (⊤ : Submodule R S) = (I.map (algebraMap R S)).restrictScalars R :=
Eq.trans (smul_restrictScalars I (⊤ : Ideal S)).symm <|
congrArg _ <| Eq.trans (Ideal.smul_eq_mul _ _) (Ideal.mul_top _)
@[simp] | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | smul_top_eq_map | null |
coe_restrictScalars {R S : Type*} [Semiring R] [Semiring S] [Module R S]
[IsScalarTower R S S] (I : Ideal S) : (I.restrictScalars R : Set S) = ↑I :=
rfl | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | coe_restrictScalars | null |
@[simp]
restrictScalars_mul {R S : Type*} [Semiring R] [Semiring S] [Module R S]
[IsScalarTower R S S] (I J : Ideal S) :
(I * J).restrictScalars R = I.restrictScalars R * J.restrictScalars R :=
rfl | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | restrictScalars_mul | The smallest `S`-submodule that contains all `x ∈ I * y ∈ J`
is also the smallest `R`-submodule that does so. |
map_comap_of_surjective (I : Ideal S) : map f (comap f I) = I :=
le_antisymm (map_le_iff_le_comap.2 le_rfl) fun s hsi =>
let ⟨r, hfrs⟩ := hf s
hfrs ▸ (mem_map_of_mem f <| show f r ∈ I from hfrs.symm ▸ hsi) | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_comap_of_surjective | null |
giMapComap : GaloisInsertion (map f) (comap f) :=
GaloisInsertion.monotoneIntro (gc_map_comap f).monotone_u (gc_map_comap f).monotone_l
(fun _ => le_comap_map) (map_comap_of_surjective _ hf) | def | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | giMapComap | `map` and `comap` are adjoint, and the composition `map f ∘ comap f` is the
identity |
map_surjective_of_surjective : Surjective (map f) :=
(giMapComap f hf).l_surjective | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_surjective_of_surjective | null |
comap_injective_of_surjective : Injective (comap f) :=
(giMapComap f hf).u_injective | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_injective_of_surjective | null |
map_sup_comap_of_surjective (I J : Ideal S) : (I.comap f ⊔ J.comap f).map f = I ⊔ J :=
(giMapComap f hf).l_sup_u _ _ | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_sup_comap_of_surjective | null |
map_iSup_comap_of_surjective (K : ι → Ideal S) : (⨆ i, (K i).comap f).map f = iSup K :=
(giMapComap f hf).l_iSup_u _ | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_iSup_comap_of_surjective | null |
map_inf_comap_of_surjective (I J : Ideal S) : (I.comap f ⊓ J.comap f).map f = I ⊓ J :=
(giMapComap f hf).l_inf_u _ _ | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_inf_comap_of_surjective | null |
map_iInf_comap_of_surjective (K : ι → Ideal S) : (⨅ i, (K i).comap f).map f = iInf K :=
(giMapComap f hf).l_iInf_u _ | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_iInf_comap_of_surjective | null |
mem_image_of_mem_map_of_surjective {I : Ideal R} {y} (H : y ∈ map f I) : y ∈ f '' I :=
Submodule.span_induction (hx := H) (fun _ => id) ⟨0, I.zero_mem, map_zero f⟩
(fun _ _ _ _ ⟨x1, hx1i, hxy1⟩ ⟨x2, hx2i, hxy2⟩ =>
⟨x1 + x2, I.add_mem hx1i hx2i, hxy1 ▸ hxy2 ▸ map_add f _ _⟩)
fun c _ _ ⟨x, hxi, hxy⟩ =>
let ⟨d, hdc⟩ := hf c
⟨d * x, I.mul_mem_left _ hxi, hdc ▸ hxy ▸ map_mul f _ _⟩ | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | mem_image_of_mem_map_of_surjective | null |
mem_map_iff_of_surjective {I : Ideal R} {y} : y ∈ map f I ↔ ∃ x, x ∈ I ∧ f x = y :=
⟨fun h => (Set.mem_image _ _ _).2 (mem_image_of_mem_map_of_surjective f hf h), fun ⟨_, hx⟩ =>
hx.right ▸ mem_map_of_mem f hx.left⟩ | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | mem_map_iff_of_surjective | null |
le_map_of_comap_le_of_surjective : comap f K ≤ I → K ≤ map f I := fun h =>
map_comap_of_surjective f hf K ▸ map_mono h | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | le_map_of_comap_le_of_surjective | null |
map_comap_eq_self_of_equiv {E : Type*} [EquivLike E R S] [RingEquivClass E R S] (e : E)
(I : Ideal S) : map e (comap e I) = I :=
I.map_comap_of_surjective e (EquivLike.surjective e) | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_comap_eq_self_of_equiv | null |
map_eq_submodule_map (f : R →+* S) [h : RingHomSurjective f] (I : Ideal R) :
I.map f = Submodule.map f.toSemilinearMap I :=
Submodule.ext fun _ => mem_map_iff_of_surjective f h.1 | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_eq_submodule_map | null |
IsMaximal.comap_piEvalRingHom {ι : Type*} {R : ι → Type*} [∀ i, Semiring (R i)]
{i : ι} {I : Ideal (R i)} (h : I.IsMaximal) : (I.comap <| Pi.evalRingHom R i).IsMaximal := by
refine isMaximal_iff.mpr ⟨I.ne_top_iff_one.mp h.ne_top, fun J x le hxI hxJ ↦ ?_⟩
have ⟨r, y, hy, eq⟩ := h.exists_inv hxI
classical
convert J.add_mem (J.mul_mem_left (update 0 i r) hxJ)
(b := update 1 i y) (le <| by apply update_self i y 1 ▸ hy)
ext j
obtain rfl | ne := eq_or_ne j i
· simpa [eq_comm] using eq
· simp [update_of_ne ne] | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | IsMaximal.comap_piEvalRingHom | null |
comap_le_comap_iff_of_surjective (hf : Function.Surjective f) (I J : Ideal S) :
comap f I ≤ comap f J ↔ I ≤ J :=
⟨fun h => (map_comap_of_surjective f hf I).symm.le.trans (map_le_of_le_comap h), fun h =>
le_comap_of_map_le ((map_comap_of_surjective f hf I).le.trans h)⟩ | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_le_comap_iff_of_surjective | null |
orderEmbeddingOfSurjective (hf : Function.Surjective f) : Ideal S ↪o Ideal R where
toFun := comap f
inj' _ _ eq := SetLike.ext' (Set.preimage_injective.mpr hf <| SetLike.ext'_iff.mp eq)
map_rel_iff' := comap_le_comap_iff_of_surjective _ hf .. | def | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | orderEmbeddingOfSurjective | The map on ideals induced by a surjective map preserves inclusion. |
map_eq_top_or_isMaximal_of_surjective (hf : Function.Surjective f) {I : Ideal R}
(H : IsMaximal I) : map f I = ⊤ ∨ IsMaximal (map f I) :=
or_iff_not_imp_left.2 fun ne_top ↦ ⟨⟨ne_top, fun _J hJ ↦ comap_injective_of_surjective f hf <|
H.1.2 _ (le_comap_map.trans_lt <| (orderEmbeddingOfSurjective f hf).strictMono hJ)⟩⟩ | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_eq_top_or_isMaximal_of_surjective | null |
map_evalRingHom_pi {I : Π i, Ideal (R i)} (i : ι) :
(pi I).map (Pi.evalRingHom R i) = I i := by
ext r
rw [mem_map_iff_of_surjective (Pi.evalRingHom R i) (Function.surjective_eval _)]
classical refine ⟨?_, fun hr ↦ ⟨_, single_mem_pi hr, by simp⟩⟩
rintro ⟨r, hr, rfl⟩
exact hr i | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_evalRingHom_pi | null |
@[simps!] piOrderIso [Finite ι] : Ideal (Π i, R i) ≃o Π i, Ideal (R i) := .symm
{ toFun := pi
invFun I i := I.map (Pi.evalRingHom R i)
left_inv _ := funext map_evalRingHom_pi
right_inv I := by
ext r
simp_rw [mem_pi, mem_map_iff_of_surjective (Pi.evalRingHom R _) (Function.surjective_eval _)]
refine ⟨(fun ⟨r', hr'⟩ ↦ ?_) ∘ Classical.skolem.mp, fun hr i ↦ ⟨r, hr, rfl⟩⟩
have := Fintype.ofFinite ι
classical rw [show r = ∑ i, Pi.single i 1 * r' i from funext fun i ↦ by
rw [← (hr' _).2, Finset.sum_apply, Fintype.sum_eq_single i fun j ne ↦ by simp [ne]]; simp]
exact sum_mem fun i _ ↦ I.mul_mem_left _ (hr' i).1
map_rel_iff' := pi_le_pi_iff } | def | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | piOrderIso | Ideals in a finite direct product semiring `Πᵢ Rᵢ` are identified with tuples of ideals
in the individual semirings, in an order-preserving way.
(Note that this is not in general true for infinite direct products:
If infinitely many of the `Rᵢ` are nontrivial, then there exists an ideal of `Πᵢ Rᵢ` that
is not of the form `Πᵢ Iᵢ`, namely the ideal of finitely supported elements of `Πᵢ Rᵢ`
(it is also not a principal ideal).) |
comap_bot_le_of_injective (hf : Function.Injective f) : comap f ⊥ ≤ I := by
refine le_trans (fun x hx => ?_) bot_le
rw [mem_comap, Submodule.mem_bot, ← map_zero f] at hx
exact Eq.symm (hf hx) ▸ Submodule.zero_mem ⊥ | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_bot_le_of_injective | null |
comap_bot_of_injective (hf : Function.Injective f) : Ideal.comap f ⊥ = ⊥ :=
le_bot_iff.mp (Ideal.comap_bot_le_of_injective f hf) | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_bot_of_injective | null |
@[simp]
map_of_equiv {I : Ideal R} (f : R ≃+* S) :
(I.map (f : R →+* S)).map (f.symm : S →+* R) = I := by
rw [← RingEquiv.toRingHom_eq_coe, ← RingEquiv.toRingHom_eq_coe, map_map,
RingEquiv.toRingHom_eq_coe, RingEquiv.toRingHom_eq_coe, RingEquiv.symm_comp, map_id] | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_of_equiv | If `f : R ≃+* S` is a ring isomorphism and `I : Ideal R`, then `map f.symm (map f I) = I`. |
@[simp]
comap_of_equiv {I : Ideal R} (f : R ≃+* S) :
(I.comap (f.symm : S →+* R)).comap (f : R →+* S) = I := by
rw [← RingEquiv.toRingHom_eq_coe, ← RingEquiv.toRingHom_eq_coe, comap_comap,
RingEquiv.toRingHom_eq_coe, RingEquiv.toRingHom_eq_coe, RingEquiv.symm_comp, comap_id] | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_of_equiv | If `f : R ≃+* S` is a ring isomorphism and `I : Ideal R`,
then `comap f (comap f.symm I) = I`. |
map_comap_of_equiv {I : Ideal R} (f : R ≃+* S) : I.map (f : R →+* S) = I.comap f.symm :=
le_antisymm (Ideal.map_le_comap_of_inverse _ _ _ (Equiv.left_inv' _))
(Ideal.comap_le_map_of_inverse _ _ _ (Equiv.right_inv' _)) | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_comap_of_equiv | If `f : R ≃+* S` is a ring isomorphism and `I : Ideal R`, then `map f I = comap f.symm I`. |
@[simp]
comap_symm {I : Ideal R} (f : R ≃+* S) : I.comap f.symm = I.map f :=
(map_comap_of_equiv f).symm | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_symm | If `f : R ≃+* S` is a ring isomorphism and `I : Ideal R`, then `comap f.symm I = map f I`. |
@[simp]
map_symm {I : Ideal S} (f : R ≃+* S) : I.map f.symm = I.comap f :=
map_comap_of_equiv (RingEquiv.symm f)
@[simp] | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_symm | If `f : R ≃+* S` is a ring isomorphism and `I : Ideal R`, then `map f.symm I = comap f I`. |
symm_apply_mem_of_equiv_iff {I : Ideal R} {f : R ≃+* S} {y : S} :
f.symm y ∈ I ↔ y ∈ I.map f := by
rw [← comap_symm, mem_comap]
@[simp] | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | symm_apply_mem_of_equiv_iff | null |
apply_mem_of_equiv_iff {I : Ideal R} {f : R ≃+* S} {x : R} :
f x ∈ I.map f ↔ x ∈ I := by
rw [← comap_symm, Ideal.mem_comap, f.symm_apply_apply] | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | apply_mem_of_equiv_iff | null |
mem_map_of_equiv {E : Type*} [EquivLike E R S] [RingEquivClass E R S] (e : E)
{I : Ideal R} (y : S) : y ∈ map e I ↔ ∃ x ∈ I, e x = y := by
constructor
· intro h
simp_rw [show map e I = _ from map_comap_of_equiv (e : R ≃+* S)] at h
exact ⟨(e : R ≃+* S).symm y, h, (e : R ≃+* S).apply_symm_apply y⟩
· rintro ⟨x, hx, rfl⟩
exact mem_map_of_mem e hx | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | mem_map_of_equiv | null |
relIsoOfBijective : Ideal S ≃o Ideal R where
toFun := comap f
invFun := map f
left_inv := map_comap_of_surjective _ hf.2
right_inv J :=
le_antisymm
(fun _ h ↦ have ⟨y, hy, eq⟩ := (mem_map_iff_of_surjective _ hf.2).mp h; hf.1 eq ▸ hy)
le_comap_map
map_rel_iff' {_ _} := by
refine ⟨fun h ↦ ?_, comap_mono⟩
have := map_mono (f := f) h
simpa only [Equiv.coe_fn_mk, map_comap_of_surjective f hf.2] using this | def | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | relIsoOfBijective | Special case of the correspondence theorem for isomorphic rings |
comap_le_iff_le_map : comap f K ≤ I ↔ K ≤ map f I :=
⟨fun h => le_map_of_comap_le_of_surjective f hf.right h, fun h =>
(relIsoOfBijective f hf).right_inv I ▸ comap_mono h⟩ | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_le_iff_le_map | null |
comap_map_of_bijective : (I.map f).comap f = I :=
le_antisymm ((comap_le_iff_le_map f hf).mpr fun _ ↦ id) le_comap_map | lemma | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_map_of_bijective | null |
isMaximal_map_iff_of_bijective : IsMaximal (map f I) ↔ IsMaximal I := by
simpa only [isMaximal_def] using (relIsoOfBijective _ hf).symm.isCoatom_iff _ | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | isMaximal_map_iff_of_bijective | null |
isMaximal_comap_iff_of_bijective : IsMaximal (comap f K) ↔ IsMaximal K := by
simpa only [isMaximal_def] using (relIsoOfBijective _ hf).isCoatom_iff _
alias ⟨_, IsMaximal.map_bijective⟩ := isMaximal_map_iff_of_bijective
alias ⟨_, IsMaximal.comap_bijective⟩ := isMaximal_comap_iff_of_bijective | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | isMaximal_comap_iff_of_bijective | null |
map_isMaximal_of_equiv {E : Type*} [EquivLike E R S] [RingEquivClass E R S] (e : E)
{p : Ideal R} [hp : p.IsMaximal] : (map e p).IsMaximal :=
hp.map_bijective e (EquivLike.bijective e) | instance | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_isMaximal_of_equiv | A ring isomorphism sends a maximal ideal to a maximal ideal. |
comap_isMaximal_of_equiv {E : Type*} [EquivLike E R S] [RingEquivClass E R S] (e : E)
{p : Ideal S} [hp : p.IsMaximal] : (comap e p).IsMaximal :=
hp.comap_bijective e (EquivLike.bijective e) | instance | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_isMaximal_of_equiv | The pullback of a maximal ideal under a ring isomorphism is a maximal ideal. |
isMaximal_iff_of_bijective : (⊥ : Ideal R).IsMaximal ↔ (⊥ : Ideal S).IsMaximal :=
⟨fun h ↦ map_bot (f := f) ▸ h.map_bijective f hf, fun h ↦ have e := RingEquiv.ofBijective f hf
map_bot (f := e.symm) ▸ h.map_bijective _ e.symm.bijective⟩ | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | isMaximal_iff_of_bijective | null |
comap_map_of_surjective (hf : Function.Surjective f) (I : Ideal R) :
comap f (map f I) = I ⊔ comap f ⊥ :=
le_antisymm
(fun r h =>
let ⟨s, hsi, hfsr⟩ := mem_image_of_mem_map_of_surjective f hf h
Submodule.mem_sup.2
⟨s, hsi, r - s, (Submodule.mem_bot S).2 <| by rw [map_sub, hfsr, sub_self],
add_sub_cancel s r⟩)
(sup_le (map_le_iff_le_comap.1 le_rfl) (comap_mono bot_le)) | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_map_of_surjective | null |
relIsoOfSurjective (hf : Function.Surjective f) :
Ideal S ≃o { p : Ideal R // comap f ⊥ ≤ p } where
toFun J := ⟨comap f J, comap_mono bot_le⟩
invFun I := map f I.1
left_inv J := map_comap_of_surjective f hf J
right_inv I :=
Subtype.eq <|
show comap f (map f I.1) = I.1 from
(comap_map_of_surjective f hf I).symm ▸ le_antisymm (sup_le le_rfl I.2) le_sup_left
map_rel_iff' {I1 I2} :=
⟨fun H => map_comap_of_surjective f hf I1 ▸ map_comap_of_surjective f hf I2 ▸ map_mono H,
comap_mono⟩ | def | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | relIsoOfSurjective | Correspondence theorem |
comap_isMaximal_of_surjective (hf : Function.Surjective f) {K : Ideal S} [H : IsMaximal K] :
IsMaximal (comap f K) := by
refine ⟨⟨comap_ne_top _ H.1.1, fun J hJ => ?_⟩⟩
suffices map f J = ⊤ by
have := congr_arg (comap f) this
rw [comap_top, comap_map_of_surjective _ hf, eq_top_iff] at this
rw [eq_top_iff]
exact le_trans this (sup_le (le_of_eq rfl) (le_trans (comap_mono bot_le) (le_of_lt hJ)))
refine
H.1.2 (map f J)
(lt_of_le_of_ne (le_map_of_comap_le_of_surjective _ hf (le_of_lt hJ)) fun h =>
ne_of_lt hJ (_root_.trans (congr_arg (comap f) h) ?_))
rw [comap_map_of_surjective _ hf, sup_eq_left]
exact le_trans (comap_mono bot_le) (le_of_lt hJ) | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_isMaximal_of_surjective | null |
protected map_mul {R} [Semiring R] [FunLike F R S] [RingHomClass F R S]
(f : F) (I J : Ideal R) :
map f (I * J) = map f I * map f J :=
le_antisymm
(map_le_iff_le_comap.2 <|
mul_le.2 fun r hri s hsj =>
show (f (r * s)) ∈ map f I * map f J by
rw [map_mul]; exact mul_mem_mul (mem_map_of_mem f hri) (mem_map_of_mem f hsj))
(span_mul_span (↑f '' ↑I) (↑f '' ↑J) ▸ (span_le.2 <|
Set.iUnion₂_subset fun _ ⟨r, hri, hfri⟩ =>
Set.iUnion₂_subset fun _ ⟨s, hsj, hfsj⟩ =>
Set.singleton_subset_iff.2 <|
hfri ▸ hfsj ▸ by rw [← map_mul]; exact mem_map_of_mem f (mul_mem_mul hri hsj))) | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_mul | null |
@[simps]
mapHom : Ideal R →+* Ideal S where
toFun := map f
map_mul' := Ideal.map_mul f
map_one' := by simp only [one_eq_top, Ideal.map_top f]
map_add' I J := Ideal.map_sup f I J
map_zero' := Ideal.map_bot | def | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | mapHom | The pushforward `Ideal.map` as a (semi)ring homomorphism. |
protected map_pow (n : ℕ) : map f (I ^ n) = map f I ^ n :=
map_pow (mapHom f) I n | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_pow | null |
comap_radical : comap f (radical K) = radical (comap f K) := by
ext
simp [radical]
variable {K} | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_radical | null |
IsRadical.comap (hK : K.IsRadical) : (comap f K).IsRadical := by
rw [← hK.radical, comap_radical]
apply radical_isRadical
variable {I J L} | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | IsRadical.comap | null |
map_radical_le : map f (radical I) ≤ radical (map f I) :=
map_le_iff_le_comap.2 fun r ⟨n, hrni⟩ => ⟨n, map_pow f r n ▸ mem_map_of_mem f hrni⟩ | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | map_radical_le | null |
le_comap_mul : comap f K * comap f L ≤ comap f (K * L) :=
map_le_iff_le_comap.1 <|
(Ideal.map_mul f (comap f K) (comap f L)).symm ▸
mul_mono (map_le_iff_le_comap.2 <| le_rfl) (map_le_iff_le_comap.2 <| le_rfl) | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | le_comap_mul | null |
le_comap_pow (n : ℕ) : K.comap f ^ n ≤ (K ^ n).comap f := by
induction n with
| zero =>
rw [pow_zero, pow_zero, Ideal.one_eq_top, Ideal.one_eq_top]
exact rfl.le
| succ n n_ih =>
rw [pow_succ, pow_succ]
exact (Ideal.mul_mono_left n_ih).trans (Ideal.le_comap_mul f) | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | le_comap_pow | null |
disjoint_map_primeCompl_iff_comap_le {S : Type*} [Semiring S] {f : R →+* S}
{p : Ideal R} {I : Ideal S} [p.IsPrime] :
Disjoint (I : Set S) (p.primeCompl.map f) ↔ I.comap f ≤ p :=
(@Set.disjoint_image_right _ _ f p.primeCompl I).trans disjoint_compl_right_iff | lemma | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | disjoint_map_primeCompl_iff_comap_le | null |
comap_map_eq_self_iff_of_isPrime {S : Type*} [CommSemiring S] {f : R →+* S}
(p : Ideal R) [p.IsPrime] :
(p.map f).comap f = p ↔ (∃ (q : Ideal S), q.IsPrime ∧ q.comap f = p) := by
refine ⟨fun hp ↦ ?_, ?_⟩
· obtain ⟨q, hq₁, hq₂, hq₃⟩ := Ideal.exists_le_prime_disjoint _ _
(disjoint_map_primeCompl_iff_comap_le.mpr hp.le)
exact ⟨q, hq₁, le_antisymm (disjoint_map_primeCompl_iff_comap_le.mp hq₃)
(map_le_iff_le_comap.mp hq₂)⟩
· rintro ⟨q, hq, rfl⟩
simp | lemma | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_map_eq_self_iff_of_isPrime | For a prime ideal `p` of `R`, `p` extended to `S` and
restricted back to `R` is `p` if and only if `p` is the restriction of a prime in `S`. |
ker : Ideal R :=
Ideal.comap f ⊥ | def | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | ker | Kernel of a ring homomorphism as an ideal of the domain. |
@[simp] mem_ker {r} : r ∈ ker f ↔ f r = 0 := by rw [ker, Ideal.mem_comap, Submodule.mem_bot] | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | mem_ker | An element is in the kernel if and only if it maps to zero. |
ker_eq : (ker f : Set R) = Set.preimage f {0} :=
rfl | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | ker_eq | null |
ker_eq_comap_bot (f : F) : ker f = Ideal.comap f ⊥ :=
rfl | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | ker_eq_comap_bot | null |
comap_ker (f : S →+* R) (g : T →+* S) : (ker f).comap g = ker (f.comp g) := by
rw [RingHom.ker_eq_comap_bot, Ideal.comap_comap, RingHom.ker_eq_comap_bot] | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | comap_ker | null |
one_notMem_ker [Nontrivial S] (f : F) : (1 : R) ∉ ker f := by
rw [mem_ker, map_one]
exact one_ne_zero
@[deprecated (since := "2025-05-23")] alias not_one_mem_ker := one_notMem_ker | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | one_notMem_ker | If the target is not the zero ring, then one is not in the kernel. |
ker_ne_top [Nontrivial S] (f : F) : ker f ≠ ⊤ :=
(Ideal.ne_top_iff_one _).mpr <| one_notMem_ker f | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | ker_ne_top | null |
_root_.Pi.ker_ringHom {ι : Type*} {R : ι → Type*} [∀ i, Semiring (R i)]
(φ : ∀ i, S →+* R i) : ker (Pi.ringHom φ) = ⨅ i, ker (φ i) := by
ext x
simp [mem_ker, funext_iff]
@[simp] | lemma | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | _root_.Pi.ker_ringHom | null |
ker_rangeSRestrict (f : R →+* S) : ker f.rangeSRestrict = ker f :=
Ideal.ext fun _ ↦ Subtype.ext_iff
@[simp] | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | ker_rangeSRestrict | null |
ker_coe_equiv (f : R ≃+* S) : ker (f : R →+* S) = ⊥ := by
ext; simp | theorem | RingTheory | [
"Mathlib.Data.DFinsupp.Module",
"Mathlib.RingTheory.Ideal.Operations"
] | Mathlib/RingTheory/Ideal/Maps.lean | ker_coe_equiv | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.