File: Mathlib/Algebra/Category/Ring/Constructions.lean

full_name: CommRingCat.pushoutCocone
code: /-- The explicit cocone with tensor products as the fibered product in `CommRingCat`. -/
def pushoutCocone : Limits.PushoutCocone
    (CommRingCat.ofHom (algebraMap R A)) (CommRingCat.ofHom (algebraMap R B)) 
goal: CategoryTheory.Limits.PushoutCocone (CommRingCat.ofHom (algebraMap R A)) (CommRingCat.ofHom (algebraMap R B))

full_name: CommRingCat.pushoutCocone_inl
code: @[simp]
theorem pushoutCocone_inl :
    (pushoutCocone R A B).inl = Algebra.TensorProduct.includeLeftRingHom (A := A) 
goal: (CommRingCat.pushoutCocone R A B).inl = Algebra.TensorProduct.includeLeftRingHom

full_name: CommRingCat.pushoutCocone_inr
code: @[simp]
theorem pushoutCocone_inr :
    (pushoutCocone R A B).inr = Algebra.TensorProduct.includeRight.toRingHom (A := B) 
goal: (CommRingCat.pushoutCocone R A B).inr = Algebra.TensorProduct.includeRight.toRingHom

full_name: CommRingCat.pushoutCocone_pt
code: @[simp]
theorem pushoutCocone_pt :
    (pushoutCocone R A B).pt = CommRingCat.of (A ⊗[R] B) 
goal: (CommRingCat.pushoutCocone R A B).pt = CommRingCat.of (A ⊗[R] B)

full_name: CommRingCat.pushoutCoconeIsColimit
code: /-- Verify that the `pushout_cocone` is indeed the colimit. -/
def pushoutCoconeIsColimit : Limits.IsColimit (pushoutCocone R A B) 
goal: CategoryTheory.Limits.IsColimit (CommRingCat.pushoutCocone R A B)

full_name: CommRingCat.punitIsTerminal
code: /-- The trivial ring is the (strict) terminal object of `CommRingCat`. -/
def punitIsTerminal : IsTerminal (CommRingCat.of.{u} PUnit) 
goal: CategoryTheory.Limits.IsTerminal (CommRingCat.of PUnit.{u + 1})

full_name: CommRingCat.commRingCat_hasStrictTerminalObjects
code: instance commRingCat_hasStrictTerminalObjects : HasStrictTerminalObjects CommRingCat.{u} 
goal: CategoryTheory.Limits.HasStrictTerminalObjects CommRingCat

full_name: CommRingCat.subsingleton_of_isTerminal
code: theorem subsingleton_of_isTerminal {X : CommRingCat} (hX : IsTerminal X) : Subsingleton X 
goal: Subsingleton ↑X

full_name: CommRingCat.zIsInitial
code: /-- `ℤ` is the initial object of `CommRingCat`. -/
def zIsInitial : IsInitial (CommRingCat.of ℤ) 
goal: CategoryTheory.Limits.IsInitial (CommRingCat.of ℤ)

full_name: CommRingCat.prodFan
code: /-- The product in `CommRingCat` is the cartesian product. This is the binary fan. -/
@[simps! pt]
def prodFan : BinaryFan A B 
goal: CategoryTheory.Limits.BinaryFan A B

full_name: CommRingCat.prodFan_pt
code: /-- The product in `CommRingCat` is the cartesian product. This is the binary fan. -/
@[simps! pt]
def prodFan : BinaryFan A B 
goal: (A.prodFan B).pt = CommRingCat.of (↑A × ↑B)

full_name: CommRingCat.prodFanIsLimit
code: /-- The product in `CommRingCat` is the cartesian product. -/
def prodFanIsLimit : IsLimit (prodFan A B) 
goal: CategoryTheory.Limits.IsLimit (A.prodFan B)

full_name: CommRingCat.piFan
code: /--
The categorical product of rings is the cartesian product of rings. This is its `Fan`.
-/
@[simps! pt]
def piFan : Fan R 
goal: CategoryTheory.Limits.Fan R

full_name: CommRingCat.piFan_pt
code: /--
The categorical product of rings is the cartesian product of rings. This is its `Fan`.
-/
@[simps! pt]
def piFan : Fan R 
goal: (CommRingCat.piFan R).pt = CommRingCat.of ((i : ι) → ↑(R i))

full_name: CommRingCat.piFanIsLimit
code: /--
The categorical product of rings is the cartesian product of rings.
-/
def piFanIsLimit : IsLimit (piFan R) 
goal: CategoryTheory.Limits.IsLimit (CommRingCat.piFan R)

full_name: CommRingCat.piIsoPi
code: /--
The categorical product and the usual product agrees
-/
def piIsoPi : ∏ᶜ R ≅ CommRingCat.of ((i : ι) → R i) 
goal: ∏ᶜ R ≅ CommRingCat.of ((i : ι) → ↑(R i))

full_name: RingEquiv.piEquivPi
code: /--
The categorical product and the usual product agrees
-/
def _root_.RingEquiv.piEquivPi (R : ι → Type u) [∀ i, CommRing (R i)] :
    (∏ᶜ (fun i : ι ↦ CommRingCat.of (R i)) : CommRingCat.{u}) ≃+* ((i : ι) → R i) 
goal: ↑(∏ᶜ fun i => CommRingCat.of (R i)) ≃+* ((i : ι) → R i)

full_name: CommRingCat.equalizerFork
code: /-- The equalizer in `CommRingCat` is the equalizer as sets. This is the equalizer fork. -/
def equalizerFork : Fork f g 
goal: CategoryTheory.Limits.Fork f g

full_name: CommRingCat.equalizerForkIsLimit
code: /-- The equalizer in `CommRingCat` is the equalizer as sets. -/
def equalizerForkIsLimit : IsLimit (equalizerFork f g) 
goal: CategoryTheory.Limits.IsLimit (CommRingCat.equalizerFork f g)

full_name: CommRingCat.instIsLocalRingHomαCommRingObjWalkingParallelPairFunctorConstPtEqualizerForkZeroParallelPairι
code: instance : IsLocalRingHom (equalizerFork f g).ι 
goal: IsLocalRingHom (CommRingCat.equalizerFork f g).ι

full_name: CommRingCat.equalizer_ι_isLocalRingHom
code: instance equalizer_ι_isLocalRingHom (F : WalkingParallelPair ⥤ CommRingCat.{u}) :
    IsLocalRingHom (limit.π F WalkingParallelPair.zero) 
goal: IsLocalRingHom (CategoryTheory.Limits.limit.π F CategoryTheory.Limits.WalkingParallelPair.zero)

full_name: CommRingCat.equalizer_ι_is_local_ring_hom'
code: instance equalizer_ι_is_local_ring_hom' (F : WalkingParallelPairᵒᵖ ⥤ CommRingCat.{u}) :
    IsLocalRingHom (limit.π F (Opposite.op WalkingParallelPair.one)) 
goal: IsLocalRingHom (CategoryTheory.Limits.limit.π F (Opposite.op CategoryTheory.Limits.WalkingParallelPair.one))

full_name: CommRingCat.pullbackCone
code: /-- In the category of `CommRingCat`, the pullback of `f : A ⟶ C` and `g : B ⟶ C` is the `eqLocus`
of the two maps `A × B ⟶ C`. This is the constructed pullback cone.
-/
def pullbackCone {A B C : CommRingCat.{u}} (f : A ⟶ C) (g : B ⟶ C) : PullbackCone f g 
goal: CategoryTheory.Limits.PullbackCone f g

full_name: CommRingCat.pullbackConeIsLimit
code: /-- The constructed pullback cone is indeed the limit. -/
def pullbackConeIsLimit {A B C : CommRingCat.{u}} (f : A ⟶ C) (g : B ⟶ C) :
    IsLimit (pullbackCone f g) 
goal: CategoryTheory.Limits.IsLimit (CommRingCat.pullbackCone f g)