File: Mathlib/Algebra/Ring/Prod.lean

full_name: Prod.instDistrib
code: /-- Product of two distributive types is distributive. -/
instance instDistrib [Distrib R] [Distrib S] : Distrib (R × S) 
goal: Distrib (R × S)

full_name: Prod.instNonUnitalNonAssocSemiring
code: /-- Product of two `NonUnitalNonAssocSemiring`s is a `NonUnitalNonAssocSemiring`. -/
instance instNonUnitalNonAssocSemiring [NonUnitalNonAssocSemiring R] [NonUnitalNonAssocSemiring S] :
    NonUnitalNonAssocSemiring (R × S) 
goal: NonUnitalNonAssocSemiring (R × S)

full_name: Prod.instNonUnitalSemiring
code: /-- Product of two `NonUnitalSemiring`s is a `NonUnitalSemiring`. -/
instance instNonUnitalSemiring [NonUnitalSemiring R] [NonUnitalSemiring S] :
    NonUnitalSemiring (R × S) 
goal: NonUnitalSemiring (R × S)

full_name: Prod.instNonAssocSemiring
code: /-- Product of two `NonAssocSemiring`s is a `NonAssocSemiring`. -/
instance instNonAssocSemiring [NonAssocSemiring R] [NonAssocSemiring S] :
    NonAssocSemiring (R × S) 
goal: NonAssocSemiring (R × S)

full_name: Prod.instSemiring
code: /-- Product of two semirings is a semiring. -/
instance instSemiring [Semiring R] [Semiring S] : Semiring (R × S) 
goal: Semiring (R × S)

full_name: Prod.instNonUnitalCommSemiring
code: /-- Product of two `NonUnitalCommSemiring`s is a `NonUnitalCommSemiring`. -/
instance instNonUnitalCommSemiring [NonUnitalCommSemiring R] [NonUnitalCommSemiring S] :
    NonUnitalCommSemiring (R × S) 
goal: NonUnitalCommSemiring (R × S)

full_name: Prod.instCommSemiring
code: /-- Product of two commutative semirings is a commutative semiring. -/
instance instCommSemiring [CommSemiring R] [CommSemiring S] : CommSemiring (R × S) 
goal: CommSemiring (R × S)

full_name: Prod.instNonUnitalNonAssocRing
code: instance instNonUnitalNonAssocRing [NonUnitalNonAssocRing R] [NonUnitalNonAssocRing S] :
    NonUnitalNonAssocRing (R × S) 
goal: NonUnitalNonAssocRing (R × S)

full_name: Prod.instNonUnitalRing
code: instance instNonUnitalRing [NonUnitalRing R] [NonUnitalRing S] : NonUnitalRing (R × S) 
goal: NonUnitalRing (R × S)

full_name: Prod.instNonAssocRing
code: instance instNonAssocRing [NonAssocRing R] [NonAssocRing S] : NonAssocRing (R × S) 
goal: NonAssocRing (R × S)

full_name: Prod.instRing
code: /-- Product of two rings is a ring. -/
instance instRing [Ring R] [Ring S] : Ring (R × S) 
goal: Ring (R × S)

full_name: Prod.instNonUnitalCommRing
code: /-- Product of two `NonUnitalCommRing`s is a `NonUnitalCommRing`. -/
instance instNonUnitalCommRing [NonUnitalCommRing R] [NonUnitalCommRing S] :
    NonUnitalCommRing (R × S) 
goal: NonUnitalCommRing (R × S)

full_name: Prod.instCommRing
code: /-- Product of two commutative rings is a commutative ring. -/
instance instCommRing [CommRing R] [CommRing S] : CommRing (R × S) 
goal: CommRing (R × S)

full_name: NonUnitalRingHom.fst
code: /-- Given non-unital semirings `R`, `S`, the natural projection homomorphism from `R × S` to `R`. -/
def fst : R × S →ₙ+* R 
goal: R × S →ₙ+* R

full_name: NonUnitalRingHom.snd
code: /-- Given non-unital semirings `R`, `S`, the natural projection homomorphism from `R × S` to `S`. -/
def snd : R × S →ₙ+* S 
goal: R × S →ₙ+* S

full_name: NonUnitalRingHom.coe_fst
code: @[simp]
theorem coe_fst : ⇑(fst R S) = Prod.fst 
goal: ⇑(NonUnitalRingHom.fst R S) = Prod.fst

full_name: NonUnitalRingHom.coe_snd
code: @[simp]
theorem coe_snd : ⇑(snd R S) = Prod.snd 
goal: ⇑(NonUnitalRingHom.snd R S) = Prod.snd

full_name: NonUnitalRingHom.prod
code: /-- Combine two non-unital ring homomorphisms `f : R →ₙ+* S`, `g : R →ₙ+* T` into
`f.prod g : R →ₙ+* S × T` given by `(f.prod g) x = (f x, g x)` -/
protected def prod (f : R →ₙ+* S) (g : R →ₙ+* T) : R →ₙ+* S × T 
goal: R →ₙ+* S × T

full_name: NonUnitalRingHom.prod_apply
code: @[simp]
theorem prod_apply (x) : f.prod g x = (f x, g x) 
goal: (f.prod g) x = (f x, g x)

full_name: NonUnitalRingHom.fst_comp_prod
code: @[simp]
theorem fst_comp_prod : (fst S T).comp (f.prod g) = f 
goal: (NonUnitalRingHom.fst S T).comp (f.prod g) = f

full_name: NonUnitalRingHom.snd_comp_prod
code: @[simp]
theorem snd_comp_prod : (snd S T).comp (f.prod g) = g 
goal: (NonUnitalRingHom.snd S T).comp (f.prod g) = g

full_name: NonUnitalRingHom.prod_unique
code: theorem prod_unique (f : R →ₙ+* S × T) : ((fst S T).comp f).prod ((snd S T).comp f) = f 
goal: ((NonUnitalRingHom.fst S T).comp f).prod ((NonUnitalRingHom.snd S T).comp f) = f

full_name: NonUnitalRingHom.prodMap
code: /-- `Prod.map` as a `NonUnitalRingHom`. -/
def prodMap : R × S →ₙ+* R' × S' 
goal: R × S →ₙ+* R' × S'

full_name: NonUnitalRingHom.prodMap_def
code: theorem prodMap_def : prodMap f g = (f.comp (fst R S)).prod (g.comp (snd R S)) 
goal: f.prodMap g = (f.comp (NonUnitalRingHom.fst R S)).prod (g.comp (NonUnitalRingHom.snd R S))

full_name: NonUnitalRingHom.coe_prodMap
code: @[simp]
theorem coe_prodMap : ⇑(prodMap f g) = Prod.map f g 
goal: ⇑(f.prodMap g) = Prod.map ⇑f ⇑g

full_name: NonUnitalRingHom.prod_comp_prodMap
code: theorem prod_comp_prodMap (f : T →ₙ+* R) (g : T →ₙ+* S) (f' : R →ₙ+* R') (g' : S →ₙ+* S') :
    (f'.prodMap g').comp (f.prod g) = (f'.comp f).prod (g'.comp g) 
goal: (f'.prodMap g').comp (f.prod g) = (f'.comp f).prod (g'.comp g)

full_name: RingHom.fst
code: /-- Given semirings `R`, `S`, the natural projection homomorphism from `R × S` to `R`. -/
def fst : R × S →+* R 
goal: R × S →+* R

full_name: RingHom.snd
code: /-- Given semirings `R`, `S`, the natural projection homomorphism from `R × S` to `S`. -/
def snd : R × S →+* S 
goal: R × S →+* S

full_name: RingHom.instRingHomSurjectiveProdFst
code: instance (R S) [Semiring R] [Semiring S] : RingHomSurjective (fst R S) 
goal: RingHomSurjective (RingHom.fst R S)

full_name: RingHom.instRingHomSurjectiveProdSnd
code: instance (R S) [Semiring R] [Semiring S] : RingHomSurjective (snd R S) 
goal: RingHomSurjective (RingHom.snd R S)

full_name: RingHom.coe_fst
code: @[simp]
theorem coe_fst : ⇑(fst R S) = Prod.fst 
goal: ⇑(RingHom.fst R S) = Prod.fst

full_name: RingHom.coe_snd
code: @[simp]
theorem coe_snd : ⇑(snd R S) = Prod.snd 
goal: ⇑(RingHom.snd R S) = Prod.snd

full_name: RingHom.prod
code: /-- Combine two ring homomorphisms `f : R →+* S`, `g : R →+* T` into `f.prod g : R →+* S × T`
given by `(f.prod g) x = (f x, g x)` -/
protected def prod (f : R →+* S) (g : R →+* T) : R →+* S × T 
goal: R →+* S × T

full_name: RingHom.prod_apply
code: @[simp]
theorem prod_apply (x) : f.prod g x = (f x, g x) 
goal: (f.prod g) x = (f x, g x)

full_name: RingHom.fst_comp_prod
code: @[simp]
theorem fst_comp_prod : (fst S T).comp (f.prod g) = f 
goal: (RingHom.fst S T).comp (f.prod g) = f

full_name: RingHom.snd_comp_prod
code: @[simp]
theorem snd_comp_prod : (snd S T).comp (f.prod g) = g 
goal: (RingHom.snd S T).comp (f.prod g) = g

full_name: RingHom.prod_unique
code: theorem prod_unique (f : R →+* S × T) : ((fst S T).comp f).prod ((snd S T).comp f) = f 
goal: ((RingHom.fst S T).comp f).prod ((RingHom.snd S T).comp f) = f

full_name: RingHom.prodMap
code: /-- `Prod.map` as a `RingHom`. -/
def prodMap : R × S →+* R' × S' 
goal: R × S →+* R' × S'

full_name: RingHom.prodMap_def
code: theorem prodMap_def : prodMap f g = (f.comp (fst R S)).prod (g.comp (snd R S)) 
goal: f.prodMap g = (f.comp (RingHom.fst R S)).prod (g.comp (RingHom.snd R S))

full_name: RingHom.coe_prodMap
code: @[simp]
theorem coe_prodMap : ⇑(prodMap f g) = Prod.map f g 
goal: ⇑(f.prodMap g) = Prod.map ⇑f ⇑g

full_name: RingHom.prod_comp_prodMap
code: theorem prod_comp_prodMap (f : T →+* R) (g : T →+* S) (f' : R →+* R') (g' : S →+* S') :
    (f'.prodMap g').comp (f.prod g) = (f'.comp f).prod (g'.comp g) 
goal: (f'.prodMap g').comp (f.prod g) = (f'.comp f).prod (g'.comp g)

full_name: RingEquiv.prodComm
code: /-- Swapping components as an equivalence of (semi)rings. -/
def prodComm : R × S ≃+* S × R 
goal: R × S ≃+* S × R

full_name: RingEquiv.coe_prodComm
code: @[simp]
theorem coe_prodComm : ⇑(prodComm : R × S ≃+* S × R) = Prod.swap 
goal: ⇑RingEquiv.prodComm = Prod.swap

full_name: RingEquiv.coe_prodComm_symm
code: @[simp]
theorem coe_prodComm_symm : ⇑(prodComm : R × S ≃+* S × R).symm = Prod.swap 
goal: ⇑RingEquiv.prodComm.symm = Prod.swap

full_name: RingEquiv.fst_comp_coe_prodComm
code: @[simp]
theorem fst_comp_coe_prodComm :
    (RingHom.fst S R).comp ↑(prodComm : R × S ≃+* S × R) = RingHom.snd R S 
goal: (RingHom.fst S R).comp ↑RingEquiv.prodComm = RingHom.snd R S

full_name: RingEquiv.snd_comp_coe_prodComm
code: @[simp]
theorem snd_comp_coe_prodComm :
    (RingHom.snd S R).comp ↑(prodComm : R × S ≃+* S × R) = RingHom.fst R S 
goal: (RingHom.snd S R).comp ↑RingEquiv.prodComm = RingHom.fst R S

full_name: RingEquiv.prodProdProdComm
code: /-- Four-way commutativity of `Prod`. The name matches `mul_mul_mul_comm`. -/
@[simps apply]
def prodProdProdComm : (R × R') × S × S' ≃+* (R × S) × R' × S' 
goal: (R × R') × S × S' ≃+* (R × S) × R' × S'

full_name: RingEquiv.prodProdProdComm_apply
code: /-- Four-way commutativity of `Prod`. The name matches `mul_mul_mul_comm`. -/
@[simps apply]
def prodProdProdComm : (R × R') × S × S' ≃+* (R × S) × R' × S' 
goal: (RingEquiv.prodProdProdComm R R' S S') rrss = ((rrss.1.1, rrss.2.1), rrss.1.2, rrss.2.2)

full_name: RingEquiv.prodProdProdComm_symm
code: @[simp]
theorem prodProdProdComm_symm : (prodProdProdComm R R' S S').symm = prodProdProdComm R S R' S' 
goal: (RingEquiv.prodProdProdComm R R' S S').symm = RingEquiv.prodProdProdComm R S R' S'

full_name: RingEquiv.prodProdProdComm_toAddEquiv
code: @[simp]
theorem prodProdProdComm_toAddEquiv :
    (prodProdProdComm R R' S S' : _ ≃+ _) = AddEquiv.prodProdProdComm R R' S S' 
goal: ↑(RingEquiv.prodProdProdComm R R' S S') = AddEquiv.prodProdProdComm R R' S S'

full_name: RingEquiv.prodProdProdComm_toMulEquiv
code: @[simp]
theorem prodProdProdComm_toMulEquiv :
    (prodProdProdComm R R' S S' : _ ≃* _) = MulEquiv.prodProdProdComm R R' S S' 
goal: ↑(RingEquiv.prodProdProdComm R R' S S') = MulEquiv.prodProdProdComm R R' S S'

full_name: RingEquiv.prodProdProdComm_toEquiv
code: @[simp]
theorem prodProdProdComm_toEquiv :
    (prodProdProdComm R R' S S' : _ ≃ _) = Equiv.prodProdProdComm R R' S S' 
goal: ↑(RingEquiv.prodProdProdComm R R' S S') = Equiv.prodProdProdComm R R' S S'

full_name: RingEquiv.prodZeroRing_symm_apply
code: /-- A ring `R` is isomorphic to `R × S` when `S` is the zero ring -/
@[simps]
def prodZeroRing : R ≃+* R × S 
goal: (RingEquiv.prodZeroRing R S).symm self = self.1

full_name: RingEquiv.prodZeroRing
code: /-- A ring `R` is isomorphic to `R × S` when `S` is the zero ring -/
@[simps]
def prodZeroRing : R ≃+* R × S 
goal: R ≃+* R × S

full_name: RingEquiv.prodZeroRing_apply
code: /-- A ring `R` is isomorphic to `R × S` when `S` is the zero ring -/
@[simps]
def prodZeroRing : R ≃+* R × S 
goal: (RingEquiv.prodZeroRing R S) x = (x, 0)

full_name: RingEquiv.zeroRingProd
code: /-- A ring `R` is isomorphic to `S × R` when `S` is the zero ring -/
@[simps]
def zeroRingProd : R ≃+* S × R 
goal: R ≃+* S × R

full_name: RingEquiv.zeroRingProd_apply
code: /-- A ring `R` is isomorphic to `S × R` when `S` is the zero ring -/
@[simps]
def zeroRingProd : R ≃+* S × R 
goal: (RingEquiv.zeroRingProd R S) x = (0, x)

full_name: RingEquiv.zeroRingProd_symm_apply
code: /-- A ring `R` is isomorphic to `S × R` when `S` is the zero ring -/
@[simps]
def zeroRingProd : R ≃+* S × R 
goal: (RingEquiv.zeroRingProd R S).symm self = self.2

full_name: false_of_nontrivial_of_product_domain
code: /-- The product of two nontrivial rings is not a domain -/
theorem false_of_nontrivial_of_product_domain (R S : Type*) [Ring R] [Ring S] [IsDomain (R × S)]
    [Nontrivial R] [Nontrivial S] : False 
goal: False