File: Mathlib/RingTheory/TwoSidedIdeal/Basic.lean

full_name: TwoSidedIdeal
code: /--
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.
-/
structure TwoSidedIdeal (R : Type*) [NonUnitalNonAssocRing R] where
  /-- every two-sided-ideal is induced by a congruence relation on the ring. -/
  ringCon : RingCon R
goal: Type u_1

full_name: TwoSidedIdeal.ringCon
code: /--
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.
-/
structure TwoSidedIdeal (R : Type*) [NonUnitalNonAssocRing R] where
  /-- every two-sided-ideal is induced by a congruence relation on the ring. -/
  ringCon : RingCon R
goal: RingCon R

full_name: TwoSidedIdeal.setLike
code: instance setLike : SetLike (TwoSidedIdeal R) R 
goal: SetLike (TwoSidedIdeal R) R

full_name: TwoSidedIdeal.mem_iff
code: lemma mem_iff (x : R) : x ∈ I ↔ I.ringCon x 0 
goal: x ∈ I ↔ I.ringCon x 0

full_name: TwoSidedIdeal.rel_iff
code: lemma rel_iff (x y : R) : I.ringCon x y ↔ x - y ∈ I 
goal: I.ringCon x y ↔ x - y ∈ I

full_name: TwoSidedIdeal.coeOrderEmbedding_apply
code: /--
the coercion from two-sided-ideals to sets is an order embedding
-/
@[simps]
def coeOrderEmbedding : TwoSidedIdeal R ↪o Set R 
goal: ∀ (a : TwoSidedIdeal R), TwoSidedIdeal.coeOrderEmbedding a = ↑a

full_name: TwoSidedIdeal.coeOrderEmbedding
code: /--
the coercion from two-sided-ideals to sets is an order embedding
-/
@[simps]
def coeOrderEmbedding : TwoSidedIdeal R ↪o Set R 
goal: TwoSidedIdeal R ↪o Set R

full_name: TwoSidedIdeal.le_iff
code: lemma le_iff {I J : TwoSidedIdeal R} : I ≤ J ↔ (I : Set R) ⊆ (J : Set R) 
goal: I ≤ J ↔ ↑I ⊆ ↑J

full_name: TwoSidedIdeal.orderIsoRingCon
code: /-- Two-sided-ideals corresponds to congruence relations on a ring. -/
def orderIsoRingCon : TwoSidedIdeal R ≃o RingCon R 
goal: TwoSidedIdeal R ≃o RingCon R

full_name: TwoSidedIdeal.ringCon_injective
code: lemma ringCon_injective : Function.Injective (TwoSidedIdeal.ringCon (R := R)) 
goal: Function.Injective TwoSidedIdeal.ringCon

full_name: TwoSidedIdeal.ringCon_le_iff
code: lemma ringCon_le_iff {I J : TwoSidedIdeal R} : I ≤ J ↔ I.ringCon ≤ J.ringCon 
goal: I ≤ J ↔ I.ringCon ≤ J.ringCon

full_name: TwoSidedIdeal.ext
code: @[ext]
lemma ext {I J : TwoSidedIdeal R} (h : ∀ x, x ∈ I ↔ x ∈ J) : I = J 
goal: I = J

full_name: TwoSidedIdeal.lt_iff
code: lemma lt_iff (I J : TwoSidedIdeal R) : I < J ↔ (I : Set R) ⊂ (J : Set R) 
goal: I < J ↔ ↑I ⊂ ↑J

full_name: TwoSidedIdeal.zero_mem
code: lemma zero_mem : 0 ∈ I 
goal: 0 ∈ I

full_name: TwoSidedIdeal.add_mem
code: lemma add_mem {x y} (hx : x ∈ I) (hy : y ∈ I) : x + y ∈ I 
goal: x + y ∈ I

full_name: TwoSidedIdeal.neg_mem
code: lemma neg_mem {x} (hx : x ∈ I) : -x ∈ I 
goal: -x ∈ I

full_name: TwoSidedIdeal.instAddSubgroupClass
code: instance : AddSubgroupClass (TwoSidedIdeal R) R 
goal: AddSubgroupClass (TwoSidedIdeal R) R

full_name: TwoSidedIdeal.sub_mem
code: lemma sub_mem {x y} (hx : x ∈ I) (hy : y ∈ I) : x - y ∈ I 
goal: x - y ∈ I

full_name: TwoSidedIdeal.mul_mem_left
code: lemma mul_mem_left (x y) (hy : y ∈ I) : x * y ∈ I 
goal: x * y ∈ I

full_name: TwoSidedIdeal.mul_mem_right
code: lemma mul_mem_right (x y) (hx : x ∈ I) : x * y ∈ I 
goal: x * y ∈ I

full_name: TwoSidedIdeal.nsmul_mem
code: lemma nsmul_mem {x} (n : ℕ) (hx : x ∈ I) : n • x ∈ I 
goal: n • x ∈ I

full_name: TwoSidedIdeal.zsmul_mem
code: lemma zsmul_mem {x} (n : ℤ) (hx : x ∈ I) : n • x ∈ I 
goal: n • x ∈ I

full_name: TwoSidedIdeal.mk'
code: /--
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`.
-/
def 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 
goal: TwoSidedIdeal R

full_name: TwoSidedIdeal.mem_mk'
code: lemma mem_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)
    (x : R) :
    x ∈ mk' carrier zero_mem add_mem neg_mem mul_mem_left mul_mem_right ↔ x ∈ carrier 
goal: x ∈ TwoSidedIdeal.mk' carrier zero_mem ⋯ ⋯ ⋯ ⋯ ↔ x ∈ carrier

full_name: TwoSidedIdeal.instSMulMemClass
code: instance : SMulMemClass (TwoSidedIdeal R) R R 
goal: SMulMemClass (TwoSidedIdeal R) R R

full_name: TwoSidedIdeal.instSMulMemClassMulOpposite
code: instance : SMulMemClass (TwoSidedIdeal R) Rᵐᵒᵖ R 
goal: SMulMemClass (TwoSidedIdeal R) Rᵐᵒᵖ R

full_name: TwoSidedIdeal.instAddSubtypeMem
code: instance : Add I 
goal: Add ↥I

full_name: TwoSidedIdeal.instZeroSubtypeMem
code: instance : Zero I 
goal: Zero ↥I

full_name: TwoSidedIdeal.instSMulNatSubtypeMem
code: instance : SMul ℕ I 
goal: SMul ℕ ↥I

full_name: TwoSidedIdeal.instNegSubtypeMem
code: instance : Neg I 
goal: Neg ↥I

full_name: TwoSidedIdeal.instSubSubtypeMem
code: instance : Sub I 
goal: Sub ↥I

full_name: TwoSidedIdeal.instSMulIntSubtypeMem
code: instance : SMul ℤ I 
goal: SMul ℤ ↥I

full_name: TwoSidedIdeal.addCommGroup
code: instance addCommGroup : AddCommGroup I 
goal: AddCommGroup ↥I

full_name: TwoSidedIdeal.coeAddMonoidHom
code: /-- The coercion into the ring as a `AddMonoidHom` -/
@[simp]
def coeAddMonoidHom : I →+ R 
goal: ↥I →+ R

full_name: TwoSidedIdeal.instSMulSubtypeMem
code: instance : SMul R I 
goal: SMul R ↥I

full_name: TwoSidedIdeal.instSMulMulOppositeSubtypeMem
code: instance : SMul Rᵐᵒᵖ I 
goal: SMul Rᵐᵒᵖ ↥I

full_name: TwoSidedIdeal.leftModule
code: instance leftModule : Module R I 
goal: Module R ↥I

full_name: TwoSidedIdeal.coe_smul
code: @[simp]
lemma coe_smul {r : R} {x : I} : (r • x : R) = r * (x : R) 
goal: r • ↑x = r * ↑x

full_name: TwoSidedIdeal.rightModule
code: instance rightModule : Module Rᵐᵒᵖ I 
goal: Module Rᵐᵒᵖ ↥I

full_name: TwoSidedIdeal.coe_mop_smul
code: @[simp]
lemma coe_mop_smul {r : Rᵐᵒᵖ} {x : I} : (r • x : R) = (x : R) * r.unop 
goal: r • ↑x = ↑x * MulOpposite.unop r

full_name: TwoSidedIdeal.instSMulCommClassMulOppositeSubtypeMem
code: instance : SMulCommClass R Rᵐᵒᵖ I 
goal: SMulCommClass R Rᵐᵒᵖ ↥I

full_name: TwoSidedIdeal.subtype_apply
code: /--
For any `I : RingCon R`, when we view it as an ideal, `I.subtype` is the injective `R`-linear map
`I → R`.
-/
@[simps]
def subtype : I →ₗ[R] R 
goal: I.subtype x = ↑x

full_name: TwoSidedIdeal.subtype
code: /--
For any `I : RingCon R`, when we view it as an ideal, `I.subtype` is the injective `R`-linear map
`I → R`.
-/
@[simps]
def subtype : I →ₗ[R] R 
goal: ↥I →ₗ[R] R

full_name: TwoSidedIdeal.subtypeMop_apply
code: /--
For any `RingCon R`, when we view it as an ideal in `Rᵒᵖ`, `subtype` is the injective `Rᵐᵒᵖ`-linear
map `I → Rᵐᵒᵖ`.
-/
@[simps]
def subtypeMop : I →ₗ[Rᵐᵒᵖ] Rᵐᵒᵖ 
goal: I.subtypeMop x = MulOpposite.op ↑x

full_name: TwoSidedIdeal.subtypeMop
code: /--
For any `RingCon R`, when we view it as an ideal in `Rᵒᵖ`, `subtype` is the injective `Rᵐᵒᵖ`-linear
map `I → Rᵐᵒᵖ`.
-/
@[simps]
def subtypeMop : I →ₗ[Rᵐᵒᵖ] Rᵐᵒᵖ 
goal: ↥I →ₗ[Rᵐᵒᵖ] Rᵐᵒᵖ