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 ⌀ |
|---|---|---|---|---|---|---|
Quotient.algebraMap_quotient_map_quotient (x : R) :
letI f := algebraMap R S
algebraMap (R ⧸ p) (S ⧸ map f p) (Ideal.Quotient.mk p x) =
Ideal.Quotient.mk (map f p) (f x) :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | Quotient.algebraMap_quotient_map_quotient | null |
Quotient.mk_smul_mk_quotient_map_quotient (x : R) (y : S) :
letI f := algebraMap R S
Quotient.mk p x • Quotient.mk (map f p) y = Quotient.mk (map f p) (f x * y) :=
Algebra.smul_def _ _ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | Quotient.mk_smul_mk_quotient_map_quotient | null |
Quotient.tower_quotient_map_quotient [Algebra R S] :
IsScalarTower R (R ⧸ p) (S ⧸ map (algebraMap R S) p) :=
IsScalarTower.of_algebraMap_eq fun x => by
rw [Quotient.algebraMap_eq, Quotient.algebraMap_quotient_map_quotient,
Quotient.mk_algebraMap] | instance | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | Quotient.tower_quotient_map_quotient | null |
under : Ideal A := Ideal.comap (algebraMap A B) P | abbrev | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | under | The ideal obtained by pulling back the ideal `P` from `B` to `A`. |
under_def : P.under A = Ideal.comap (algebraMap A B) P := rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | under_def | null |
IsPrime.under [hP : P.IsPrime] : (P.under A).IsPrime :=
hP.comap (algebraMap A B)
@[simp] | instance | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | IsPrime.under | null |
under_smul : (g • P : Ideal B).under A = P.under A := by
ext a
rw [mem_comap, mem_comap, mem_pointwise_smul_iff_inv_smul_mem, smul_algebraMap]
variable (B) in | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | under_smul | null |
under_top : under A (⊤ : Ideal B) = ⊤ := comap_top
variable {A} | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | under_top | null |
@[mk_iff] LiesOver : Prop where
over : p = P.under A | class | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | LiesOver | `P` lies over `p` if `p` is the preimage of `P` by the `algebraMap`. |
over_under : P.LiesOver (P.under A) where over := rfl | instance | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | over_under | null |
over_def [P.LiesOver p] : p = P.under A := LiesOver.over | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | over_def | null |
mem_of_liesOver [P.LiesOver p] (x : A) : x ∈ p ↔ algebraMap A B x ∈ P := by
rw [P.over_def p]
rfl
variable (A B) in | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | mem_of_liesOver | null |
top_liesOver_top : (⊤ : Ideal B).LiesOver (⊤ : Ideal A) where
over := (under_top A B).symm | instance | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | top_liesOver_top | null |
eq_top_iff_of_liesOver [P.LiesOver p] : P = ⊤ ↔ p = ⊤ := by
rw [P.over_def p]
exact comap_eq_top_iff.symm
variable {P} | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | eq_top_iff_of_liesOver | null |
LiesOver.of_eq_comap [Q.LiesOver p] {F : Type*} [FunLike F B C]
[AlgHomClass F A B C] (f : F) (h : P = Q.comap f) : P.LiesOver p where
over := by
rw [h]
exact (over_def Q p).trans <|
congrFun (congrFun (congrArg comap ((f : B →ₐ[A] C).comp_algebraMap.symm)) _) Q | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | LiesOver.of_eq_comap | null |
LiesOver.of_eq_map_equiv [P.LiesOver p] {E : Type*} [EquivLike E B C]
[AlgEquivClass E A B C] (σ : E) (h : Q = P.map σ) : Q.LiesOver p := by
rw [← show _ = P.map σ from comap_symm (σ : B ≃+* C)] at h
exact of_eq_comap p (σ : B ≃ₐ[A] C).symm h
variable {p} in | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | LiesOver.of_eq_map_equiv | null |
LiesOver.smul [h : P.LiesOver p] : (g • P).LiesOver p :=
⟨h.over.trans (under_smul A P g).symm⟩
variable (P) (Q) | instance | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | LiesOver.smul | null |
comap_liesOver [Q.LiesOver p] {F : Type*} [FunLike F B C] [AlgHomClass F A B C]
(f : F) : (Q.comap f).LiesOver p :=
LiesOver.of_eq_comap p f rfl | instance | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | comap_liesOver | null |
map_equiv_liesOver [P.LiesOver p] {E : Type*} [EquivLike E B C] [AlgEquivClass E A B C]
(σ : E) : (P.map σ).LiesOver p :=
LiesOver.of_eq_map_equiv p σ rfl | instance | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | map_equiv_liesOver | null |
@[simp]
under_under : (𝔓.under B).under A = 𝔓.under A := by
simp_rw [comap_comap, ← IsScalarTower.algebraMap_eq] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | under_under | null |
LiesOver.trans [𝔓.LiesOver P] [P.LiesOver p] : 𝔓.LiesOver p where
over := by rw [P.over_def p, 𝔓.over_def P, under_under] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | LiesOver.trans | null |
LiesOver.tower_bot [hp : 𝔓.LiesOver p] [hP : 𝔓.LiesOver P] : P.LiesOver p where
over := by rw [𝔓.over_def p, 𝔓.over_def P, under_under]
variable (B) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | LiesOver.tower_bot | null |
under_liesOver_of_liesOver [𝔓.LiesOver p] : (𝔓.under B).LiesOver p :=
LiesOver.tower_bot 𝔓 (𝔓.under B) p | instance | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | under_liesOver_of_liesOver | null |
@[simp]
under_bot : under A (⊥ : Ideal B) = ⊥ :=
comap_bot_of_injective (algebraMap A B) (FaithfulSMul.algebraMap_injective A B) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | under_bot | null |
bot_liesOver_bot : (⊥ : Ideal B).LiesOver (⊥ : Ideal A) where
over := (under_bot A B).symm
variable {A B} in | instance | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | bot_liesOver_bot | null |
ne_bot_of_liesOver_of_ne_bot (hp : p ≠ ⊥) (P : Ideal B) [P.LiesOver p] : P ≠ ⊥ := by
contrapose! hp
rw [over_def P p, hp, under_bot] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | ne_bot_of_liesOver_of_ne_bot | null |
algebraOfLiesOver : Algebra (A ⧸ p) (B ⧸ P) :=
algebraQuotientOfLEComap (le_of_eq (P.over_def p))
@[simp] | instance | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | algebraOfLiesOver | If `P` lies over `p`, then canonically `B ⧸ P` is a `A ⧸ p`-algebra. |
algebraMap_mk_of_liesOver (x : A) :
algebraMap (A ⧸ p) (B ⧸ P) (Ideal.Quotient.mk p x) = Ideal.Quotient.mk P (algebraMap _ _ x) :=
rfl | lemma | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | algebraMap_mk_of_liesOver | null |
isScalarTower_of_liesOver : IsScalarTower R (A ⧸ p) (B ⧸ P) :=
IsScalarTower.of_algebraMap_eq' <|
congrArg (algebraMap B (B ⧸ P)).comp (IsScalarTower.algebraMap_eq R A B) | instance | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | isScalarTower_of_liesOver | null |
instFaithfulSMul : FaithfulSMul (A ⧸ p) (B ⧸ P) := by
rw [faithfulSMul_iff_algebraMap_injective]
rintro ⟨a⟩ ⟨b⟩ hab
apply Quotient.eq.mpr ((mem_of_liesOver P p (a - b)).mpr _)
rw [RingHom.map_sub]
exact Quotient.eq.mp hab
variable {p} in | instance | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | instFaithfulSMul | null |
nontrivial_of_liesOver_of_ne_top (hp : p ≠ ⊤) : Nontrivial (B ⧸ P) :=
Quotient.nontrivial ((eq_top_iff_of_liesOver P p).mp.mt hp) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | nontrivial_of_liesOver_of_ne_top | null |
nontrivial_of_liesOver_of_isPrime [hp : p.IsPrime] : Nontrivial (B ⧸ P) :=
nontrivial_of_liesOver_of_ne_top P hp.ne_top | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | nontrivial_of_liesOver_of_isPrime | null |
algEquivOfEqMap (h : Q = P.map σ) : (B ⧸ P) ≃ₐ[A ⧸ p] (C ⧸ Q) where
__ := quotientEquiv P Q σ h
commutes' := by
rintro ⟨x⟩
exact congrArg (Ideal.Quotient.mk Q) (AlgHomClass.commutes σ x)
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | algEquivOfEqMap | An `A ⧸ p`-algebra isomorphism between `B ⧸ P` and `C ⧸ Q` induced by an `A`-algebra
isomorphism between `B` and `C`, where `Q = σ P`. |
algEquivOfEqMap_apply (h : Q = P.map σ) (x : B) : algEquivOfEqMap p σ h x = σ x :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | algEquivOfEqMap_apply | null |
algEquivOfEqComap (h : P = Q.comap σ) : (B ⧸ P) ≃ₐ[A ⧸ p] (C ⧸ Q) :=
algEquivOfEqMap p σ ((congrArg (map σ) h).trans (Q.map_comap_eq_self_of_equiv σ)).symm
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | algEquivOfEqComap | An `A ⧸ p`-algebra isomorphism between `B ⧸ P` and `C ⧸ Q` induced by an `A`-algebra
isomorphism between `B` and `C`, where `P = σ⁻¹ Q`. |
algEquivOfEqComap_apply (h : P = Q.comap σ) (x : B) : algEquivOfEqComap p σ h x = σ x :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | algEquivOfEqComap_apply | null |
stabilizerHom : MulAction.stabilizer G P →* ((B ⧸ P) ≃ₐ[A ⧸ p] (B ⧸ P)) where
toFun g := algEquivOfEqMap p (MulSemiringAction.toAlgEquiv A B g) g.2.symm
map_one' := by
ext ⟨x⟩
exact congrArg (Ideal.Quotient.mk P) (one_smul G x)
map_mul' g h := by
ext ⟨x⟩
exact congrArg (Ideal.Quotient.mk P) (mul_smul g h x)
@[simp] theorem stabilizerHom_apply (g : MulAction.stabilizer G P) (b : B) :
stabilizerHom P p G g b = ↑(g • b) :=
rfl | def | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | stabilizerHom | If `P` lies over `p`, then the stabilizer of `P` acts on the extension `(B ⧸ P) / (A ⧸ p)`. |
primesOver : Set (Ideal B) :=
{ P : Ideal B | P.IsPrime ∧ P.LiesOver p }
variable {B} | def | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | primesOver | The set of all prime ideals in `B` that lie over an ideal `p` of `A`. |
primesOver.isPrime (Q : primesOver p B) : Q.1.IsPrime :=
Q.2.1 | instance | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | primesOver.isPrime | null |
primesOver.liesOver (Q : primesOver p B) : Q.1.LiesOver p :=
Q.2.2 | instance | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | primesOver.liesOver | null |
primesOver.mk (P : Ideal B) [hPp : P.IsPrime] [hp : P.LiesOver p] : primesOver p B :=
⟨P, ⟨hPp, hp⟩⟩
variable {p} in | abbrev | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | primesOver.mk | If an ideal `P` of `B` is prime and lying over `p`, then it is in `primesOver p B`. |
ne_bot_of_mem_primesOver {S : Type*} [Ring S] [Algebra R S] [Nontrivial S]
[NoZeroSMulDivisors R S] {p : Ideal R} (hp : p ≠ ⊥) {P : Ideal S}
(hP : P ∈ p.primesOver S) :
P ≠ ⊥ := @ne_bot_of_liesOver_of_ne_bot _ _ _ _ _ _ _ _ hp P hP.2 | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Tower",
"Mathlib.Algebra.Group.Subgroup.Actions",
"Mathlib.RingTheory.Ideal.Pointwise",
"Mathlib.RingTheory.Ideal.Quotient.Operations"
] | Mathlib/RingTheory/Ideal/Over.lean | ne_bot_of_mem_primesOver | null |
protected pointwiseDistribMulAction : DistribMulAction M (Ideal R) where
smul a := Ideal.map (MulSemiringAction.toRingHom _ _ a)
one_smul I :=
congr_arg (I.map ·) (RingHom.ext <| one_smul M) |>.trans I.map_id
mul_smul _ _ I :=
congr_arg (I.map ·) (RingHom.ext <| mul_smul _ _) |>.trans (I.map_map _ _).symm
smul_zero _ := Ideal.map_bot
smul_add _ I J := Ideal.map_sup _ I J
scoped[Pointwise] attribute [instance] Ideal.pointwiseDistribMulAction
open Pointwise | def | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Pointwise.lean | pointwiseDistribMulAction | The action on an ideal corresponding to applying the action to every element.
This is available as an instance in the `Pointwise` locale. |
protected pointwiseMulSemiringAction {R : Type*} [CommRing R] [MulSemiringAction M R] :
MulSemiringAction M (Ideal R) where
smul_one a := by simp only [Ideal.one_eq_top]; exact Ideal.map_top _
smul_mul a I J := Ideal.map_mul (MulSemiringAction.toRingHom _ _ a) I J
scoped[Pointwise] attribute [instance] Ideal.pointwiseMulSemiringAction | def | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Pointwise.lean | pointwiseMulSemiringAction | The action on an ideal corresponding to applying the action to every element.
This is available as an instance in the `Pointwise` locale. |
pointwise_smul_def {a : M} (S : Ideal R) :
a • S = S.map (MulSemiringAction.toRingHom _ _ a) :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Pointwise.lean | pointwise_smul_def | null |
smul_mem_pointwise_smul (m : M) (r : R) (S : Ideal R) : r ∈ S → m • r ∈ m • S :=
fun h => subset_span <| Set.smul_mem_smul_set h | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Pointwise.lean | smul_mem_pointwise_smul | null |
@[simp]
smul_bot (a : M) : a • (⊥ : Ideal R) = ⊥ :=
map_bot | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Pointwise.lean | smul_bot | null |
smul_sup (a : M) (S T : Ideal R) : a • (S ⊔ T) = a • S ⊔ a • T :=
map_sup _ _ _ | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Pointwise.lean | smul_sup | null |
smul_closure (a : M) (s : Set R) : a • span s = span (a • s) :=
Ideal.map_span _ _ | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Pointwise.lean | smul_closure | null |
pointwise_central_scalar [MulSemiringAction Mᵐᵒᵖ R] [IsCentralScalar M R] :
IsCentralScalar M (Ideal R) :=
⟨fun _ S => (congr_arg fun f => S.map f) <| RingHom.ext <| op_smul_eq_smul _⟩
@[simp] | instance | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Pointwise.lean | pointwise_central_scalar | null |
pointwise_smul_toAddSubmonoid (a : M) (S : Ideal R)
(ha : Function.Surjective fun r : R => a • r) :
(a • S).toAddSubmonoid = a • S.toAddSubmonoid := by
ext
exact Ideal.mem_map_iff_of_surjective _ <| by exact ha
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Pointwise.lean | pointwise_smul_toAddSubmonoid | null |
pointwise_smul_toAddSubgroup {R : Type*} [Ring R] [MulSemiringAction M R]
(a : M) (S : Ideal R) (ha : Function.Surjective fun r : R => a • r) :
(a • S).toAddSubgroup = a • S.toAddSubgroup := by
ext
exact Ideal.mem_map_iff_of_surjective _ <| by exact ha
@[deprecated (since := "2025-07-08")]
alias pointwise_smul_toAddSubGroup := pointwise_smul_toAddSubgroup | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Pointwise.lean | pointwise_smul_toAddSubgroup | null |
pointwise_smul_eq_comap {a : M} (S : Ideal R) :
a • S = S.comap (MulSemiringAction.toRingAut _ _ a).symm := by
ext
simp [pointwise_smul_def]
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Pointwise.lean | pointwise_smul_eq_comap | null |
smul_mem_pointwise_smul_iff {a : M} {S : Ideal R} {x : R} : a • x ∈ a • S ↔ x ∈ S :=
⟨fun h => by simpa using smul_mem_pointwise_smul a⁻¹ _ _ h, smul_mem_pointwise_smul _ _ _⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Pointwise.lean | smul_mem_pointwise_smul_iff | null |
mem_pointwise_smul_iff_inv_smul_mem {a : M} {S : Ideal R} {x : R} :
x ∈ a • S ↔ a⁻¹ • x ∈ S :=
⟨fun h => by simpa using smul_mem_pointwise_smul a⁻¹ _ _ h,
fun h => by simpa using smul_mem_pointwise_smul a _ _ h⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Pointwise.lean | mem_pointwise_smul_iff_inv_smul_mem | null |
mem_inv_pointwise_smul_iff {a : M} {S : Ideal R} {x : R} : x ∈ a⁻¹ • S ↔ a • x ∈ S := by
rw [mem_pointwise_smul_iff_inv_smul_mem, inv_inv]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Pointwise.lean | mem_inv_pointwise_smul_iff | null |
pointwise_smul_le_pointwise_smul_iff {a : M} {S T : Ideal R} : a • S ≤ a • T ↔ S ≤ T :=
⟨fun h => by simpa using smul_mono_right a⁻¹ h, fun h => smul_mono_right a h⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Pointwise.lean | pointwise_smul_le_pointwise_smul_iff | null |
pointwise_smul_subset_iff {a : M} {S T : Ideal R} : a • S ≤ T ↔ S ≤ a⁻¹ • T := by
rw [← pointwise_smul_le_pointwise_smul_iff (a := a⁻¹), inv_smul_smul] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Pointwise.lean | pointwise_smul_subset_iff | null |
subset_pointwise_smul_iff {a : M} {S T : Ideal R} : S ≤ a • T ↔ a⁻¹ • S ≤ T := by
rw [← pointwise_smul_le_pointwise_smul_iff (a := a⁻¹), inv_smul_smul] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Pointwise.lean | subset_pointwise_smul_iff | null |
IsPrime.smul {I : Ideal R} [H : I.IsPrime] (g : M) : (g • I).IsPrime := by
rw [I.pointwise_smul_eq_comap]
apply H.comap
@[simp] | instance | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Pointwise.lean | IsPrime.smul | null |
IsPrime.smul_iff {I : Ideal R} (g : M) : (g • I).IsPrime ↔ I.IsPrime :=
⟨fun H ↦ inv_smul_smul g I ▸ H.smul g⁻¹, fun H ↦ H.smul g⟩
/-! TODO: add `equivSMul` like we have for subgroup. -/ | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.End",
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Pointwise.lean | IsPrime.smul_iff | null |
IsPrime (I : Ideal α) : Prop where
/-- The prime ideal is not the entire ring. -/
ne_top' : I ≠ ⊤
/-- If a product lies in the prime ideal, then at least one element lies in the prime ideal. -/
mem_or_mem' : ∀ {x y : α}, x * y ∈ I → x ∈ I ∨ y ∈ I | class | RingTheory | [
"Mathlib.RingTheory.Ideal.Lattice"
] | Mathlib/RingTheory/Ideal/Prime.lean | IsPrime | An ideal `P` of a ring `R` is prime if `P ≠ R` and `xy ∈ P → x ∈ P ∨ y ∈ P` |
isPrime_iff {I : Ideal α} : IsPrime I ↔ I ≠ ⊤ ∧ ∀ {x y : α}, x * y ∈ I → x ∈ I ∨ y ∈ I :=
⟨fun h => ⟨h.1, h.2⟩, fun h => ⟨h.1, h.2⟩⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Lattice"
] | Mathlib/RingTheory/Ideal/Prime.lean | isPrime_iff | null |
IsPrime.ne_top {I : Ideal α} (hI : I.IsPrime) : I ≠ ⊤ :=
hI.1 | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Lattice"
] | Mathlib/RingTheory/Ideal/Prime.lean | IsPrime.ne_top | null |
IsPrime.one_notMem {I : Ideal α} (hI : I.IsPrime) : 1 ∉ I :=
mt (eq_top_iff_one I).2 hI.1 | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Lattice"
] | Mathlib/RingTheory/Ideal/Prime.lean | IsPrime.one_notMem | null |
one_notMem (I : Ideal α) [hI : I.IsPrime] : 1 ∉ I :=
hI.one_notMem | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Lattice"
] | Mathlib/RingTheory/Ideal/Prime.lean | one_notMem | null |
IsPrime.mem_or_mem {I : Ideal α} (hI : I.IsPrime) {x y : α} : x * y ∈ I → x ∈ I ∨ y ∈ I :=
hI.2 | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Lattice"
] | Mathlib/RingTheory/Ideal/Prime.lean | IsPrime.mem_or_mem | null |
IsPrime.mul_notMem {I : Ideal α} (hI : I.IsPrime) {x y : α} :
x ∉ I → y ∉ I → x * y ∉ I := fun hx hy h ↦
hy ((hI.mem_or_mem h).resolve_left hx)
@[deprecated (since := "2025-05-23")] alias IsPrime.mul_not_mem := IsPrime.mul_notMem | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Lattice"
] | Mathlib/RingTheory/Ideal/Prime.lean | IsPrime.mul_notMem | null |
IsPrime.mem_or_mem_of_mul_eq_zero {I : Ideal α} (hI : I.IsPrime) {x y : α} (h : x * y = 0) :
x ∈ I ∨ y ∈ I :=
hI.mem_or_mem (h.symm ▸ I.zero_mem) | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Lattice"
] | Mathlib/RingTheory/Ideal/Prime.lean | IsPrime.mem_or_mem_of_mul_eq_zero | null |
IsPrime.mem_of_pow_mem {I : Ideal α} (hI : I.IsPrime) {r : α} (n : ℕ) (H : r ^ n ∈ I) :
r ∈ I := by
induction n with
| zero =>
rw [pow_zero] at H
exact hI.one_notMem.elim H
| succ n ih =>
rw [pow_succ] at H
exact Or.casesOn (hI.mem_or_mem H) ih id | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Lattice"
] | Mathlib/RingTheory/Ideal/Prime.lean | IsPrime.mem_of_pow_mem | null |
not_isPrime_iff {I : Ideal α} :
¬I.IsPrime ↔ I = ⊤ ∨ ∃ (x : α) (_hx : x ∉ I) (y : α) (_hy : y ∉ I), x * y ∈ I := by
simp_rw [Ideal.isPrime_iff, not_and_or, Ne, Classical.not_not, not_forall, not_or]
exact
or_congr Iff.rfl
⟨fun ⟨x, y, hxy, hx, hy⟩ => ⟨x, hx, y, hy, hxy⟩, fun ⟨x, hx, y, hy, hxy⟩ =>
⟨x, y, hxy, hx, hy⟩⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Lattice"
] | Mathlib/RingTheory/Ideal/Prime.lean | not_isPrime_iff | null |
bot_prime [Nontrivial α] [NoZeroDivisors α] : (⊥ : Ideal α).IsPrime :=
⟨fun h => one_ne_zero (α := α) (by rwa [Ideal.eq_top_iff_one, Submodule.mem_bot] at h), fun h =>
mul_eq_zero.mp (by simpa only [Submodule.mem_bot] using h)⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Lattice"
] | Mathlib/RingTheory/Ideal/Prime.lean | bot_prime | null |
IsPrime.mul_mem_iff_mem_or_mem {I : Ideal α} [I.IsTwoSided] (hI : I.IsPrime) :
∀ {x y : α}, x * y ∈ I ↔ x ∈ I ∨ y ∈ I := @fun x y =>
⟨hI.mem_or_mem, by
rintro (h | h)
exacts [I.mul_mem_right y h, I.mul_mem_left x h]⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Lattice"
] | Mathlib/RingTheory/Ideal/Prime.lean | IsPrime.mul_mem_iff_mem_or_mem | null |
IsPrime.pow_mem_iff_mem {I : Ideal α} (hI : I.IsPrime) {r : α} (n : ℕ) (hn : 0 < n) :
r ^ n ∈ I ↔ r ∈ I :=
⟨hI.mem_of_pow_mem n, fun hr => I.pow_mem_of_mem hr n hn⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Lattice"
] | Mathlib/RingTheory/Ideal/Prime.lean | IsPrime.pow_mem_iff_mem | null |
primeCompl (P : Ideal α) [hp : P.IsPrime] : Submonoid α where
carrier := (Pᶜ : Set α)
one_mem' := P.one_notMem
mul_mem' {_ _} hnx hny hxy := Or.casesOn (hp.mem_or_mem hxy) hnx hny
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Lattice"
] | Mathlib/RingTheory/Ideal/Prime.lean | primeCompl | The complement of a prime ideal `P ⊆ R` is a submonoid of `R`. |
mem_primeCompl_iff {P : Ideal α} [P.IsPrime] {x : α} :
x ∈ P.primeCompl ↔ x ∉ P := Iff.rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Lattice"
] | Mathlib/RingTheory/Ideal/Prime.lean | mem_primeCompl_iff | null |
IsDomain.of_bot_isPrime (A : Type*) [Ring A] [hbp : (⊥ : Ideal A).IsPrime] : IsDomain A :=
@NoZeroDivisors.to_isDomain A _ ⟨1, 0, fun h => hbp.one_notMem h⟩ ⟨fun h => hbp.2 h⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Lattice"
] | Mathlib/RingTheory/Ideal/Prime.lean | IsDomain.of_bot_isPrime | null |
eq_bot_of_prime [h : I.IsPrime] : I = ⊥ :=
or_iff_not_imp_right.mp I.eq_bot_or_top h.1 | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Lattice"
] | Mathlib/RingTheory/Ideal/Prime.lean | eq_bot_of_prime | null |
prod : Ideal (R × S) := I.comap (RingHom.fst R S) ⊓ J.comap (RingHom.snd R S)
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | prod | `I × J` as an ideal of `R × S`. |
coe_prod (I : Ideal R) (J : Ideal S) : ↑(prod I J) = (I ×ˢ J : Set (R × S)) :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | coe_prod | null |
mem_prod {x : R × S} : x ∈ prod I J ↔ x.1 ∈ I ∧ x.2 ∈ J :=
Iff.rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | mem_prod | null |
prod_top_top : prod (⊤ : Ideal R) (⊤ : Ideal S) = ⊤ :=
Ideal.ext <| by simp
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | prod_top_top | null |
prod_bot_bot : prod (⊥ : Ideal R) (⊥ : Ideal S) = ⊥ :=
SetLike.coe_injective <| Set.singleton_prod_singleton
@[gcongr] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | prod_bot_bot | null |
prod_mono {I₁ I₂ : Ideal R} {J₁ J₂ : Ideal S} (hI : I₁ ≤ I₂) (hJ : J₁ ≤ J₂) :
prod I₁ J₁ ≤ prod I₂ J₂ :=
Set.prod_mono hI hJ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | prod_mono | null |
prod_mono_left {I₁ I₂ : Ideal R} {J : Ideal S} (hI : I₁ ≤ I₂) : prod I₁ J ≤ prod I₂ J :=
Set.prod_mono_left hI | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | prod_mono_left | null |
prod_mono_right {I : Ideal R} {J₁ J₂ : Ideal S} (hJ : J₁ ≤ J₂) : prod I J₁ ≤ prod I J₂ :=
Set.prod_mono_right hJ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | prod_mono_right | null |
ideal_prod_eq (I : Ideal (R × S)) :
I = Ideal.prod (map (RingHom.fst R S) I : Ideal R) (map (RingHom.snd R S) I) := by
apply Ideal.ext
rintro ⟨r, s⟩
rw [mem_prod, mem_map_iff_of_surjective (RingHom.fst R S) Prod.fst_surjective,
mem_map_iff_of_surjective (RingHom.snd R S) Prod.snd_surjective]
refine ⟨fun h => ⟨⟨_, ⟨h, rfl⟩⟩, ⟨_, ⟨h, rfl⟩⟩⟩, ?_⟩
rintro ⟨⟨⟨r, s'⟩, ⟨h₁, rfl⟩⟩, ⟨⟨r', s⟩, ⟨h₂, rfl⟩⟩⟩
simpa using I.add_mem (I.mul_mem_left (1, 0) h₁) (I.mul_mem_left (0, 1) h₂)
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | ideal_prod_eq | Every ideal of the product ring is of the form `I × J`, where `I` and `J` can be explicitly
given as the image under the projection maps. |
map_fst_prod (I : Ideal R) (J : Ideal S) : map (RingHom.fst R S) (prod I J) = I := by
ext x
rw [mem_map_iff_of_surjective (RingHom.fst R S) Prod.fst_surjective]
exact
⟨by
rintro ⟨x, ⟨h, rfl⟩⟩
exact h.1, fun h => ⟨⟨x, 0⟩, ⟨⟨h, Ideal.zero_mem _⟩, rfl⟩⟩⟩
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | map_fst_prod | null |
map_snd_prod (I : Ideal R) (J : Ideal S) : map (RingHom.snd R S) (prod I J) = J := by
ext x
rw [mem_map_iff_of_surjective (RingHom.snd R S) Prod.snd_surjective]
exact
⟨by
rintro ⟨x, ⟨h, rfl⟩⟩
exact h.2, fun h => ⟨⟨0, x⟩, ⟨⟨Ideal.zero_mem _, h⟩, rfl⟩⟩⟩
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | map_snd_prod | null |
map_prodComm_prod :
map ((RingEquiv.prodComm : R × S ≃+* S × R) : R × S →+* S × R) (prod I J) = prod J I := by
refine Trans.trans (ideal_prod_eq _) ?_
simp [map_map] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | map_prodComm_prod | null |
idealProdEquiv : Ideal (R × S) ≃o Ideal R × Ideal S where
toFun I := ⟨map (RingHom.fst R S) I, map (RingHom.snd R S) I⟩
invFun I := prod I.1 I.2
left_inv I := (ideal_prod_eq I).symm
right_inv := fun ⟨I, J⟩ => by simp
map_rel_iff' {I J} := by
simp only [Equiv.coe_fn_mk, ge_iff_le, Prod.mk_le_mk]
refine ⟨fun h ↦ ?_, fun h ↦ ⟨map_mono h, map_mono h⟩⟩
rw [ideal_prod_eq I, ideal_prod_eq J]
exact inf_le_inf (comap_mono h.1) (comap_mono h.2)
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | idealProdEquiv | Ideals of `R × S` are in one-to-one correspondence with pairs of ideals of `R` and ideals of
`S`. |
idealProdEquiv_symm_apply (I : Ideal R) (J : Ideal S) :
idealProdEquiv.symm ⟨I, J⟩ = prod I J :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | idealProdEquiv_symm_apply | null |
span_prod_le {s : Set R} {t : Set S} :
span (s ×ˢ t) ≤ prod (span s) (span t) := by
rw [ideal_prod_eq (span (s ×ˢ t)), map_span, map_span]
gcongr
· exact Set.fst_image_prod_subset _ _
· exact Set.snd_image_prod_subset _ _ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | span_prod_le | null |
span_prod {s : Set R} {t : Set S} (hst : s.Nonempty ↔ t.Nonempty) :
span (s ×ˢ t) = prod (span s) (span t) := by
simp_rw [iff_iff_and_or_not_and_not, Set.not_nonempty_iff_eq_empty] at hst
obtain ⟨hs, ht⟩ | ⟨rfl, rfl⟩ := hst
· conv_lhs => rw [Ideal.ideal_prod_eq (Ideal.span (s ×ˢ t))]
congr 1
· rw [Ideal.map_span]
simp [Set.fst_image_prod _ ht]
· rw [Ideal.map_span]
simp [Set.snd_image_prod hs]
· simp
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | span_prod | null |
prod_inj {I I' : Ideal R} {J J' : Ideal S} :
prod I J = prod I' J' ↔ I = I' ∧ J = J' := by
simp only [← idealProdEquiv_symm_apply, idealProdEquiv.symm.injective.eq_iff, Prod.mk_inj]
@[deprecated (since := "2025-05-22")] alias prod.ext_iff := prod_inj
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | prod_inj | null |
prod_eq_bot_iff {I : Ideal R} {J : Ideal S} :
prod I J = ⊥ ↔ I = ⊥ ∧ J = ⊥ := by
rw [← prod_inj, prod_bot_bot]
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | prod_eq_bot_iff | null |
prod_eq_top_iff {I : Ideal R} {J : Ideal S} :
prod I J = ⊤ ↔ I = ⊤ ∧ J = ⊤ := by
rw [← prod_inj, prod_top_top] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | prod_eq_top_iff | null |
isPrime_of_isPrime_prod_top {I : Ideal R} (h : (Ideal.prod I (⊤ : Ideal S)).IsPrime) :
I.IsPrime := by
constructor
· contrapose! h
rw [h, prod_top_top, isPrime_iff]
simp
· intro x y hxy
have : (⟨x, 1⟩ : R × S) * ⟨y, 1⟩ ∈ prod I ⊤ := by
rw [Prod.mk_mul_mk, mul_one, mem_prod]
exact ⟨hxy, trivial⟩
simpa using h.mem_or_mem this | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | isPrime_of_isPrime_prod_top | null |
isPrime_of_isPrime_prod_top' {I : Ideal S} (h : (Ideal.prod (⊤ : Ideal R) I).IsPrime) :
I.IsPrime := by
apply isPrime_of_isPrime_prod_top (S := R)
rw [← map_prodComm_prod]
exact map_isPrime_of_equiv (RingEquiv.prodComm (R := R) (S := S)) | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | isPrime_of_isPrime_prod_top' | null |
isPrime_ideal_prod_top {I : Ideal R} [h : I.IsPrime] : (prod I (⊤ : Ideal S)).IsPrime where
ne_top' := by simpa using h.ne_top
mem_or_mem' {x y} := by simpa using h.mem_or_mem | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Maps"
] | Mathlib/RingTheory/Ideal/Prod.lean | isPrime_ideal_prod_top | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.