File: Mathlib/CategoryTheory/Limits/Shapes/SingleObj.lean

full_name: CategoryTheory.Limits.SingleObj.instMulActionObjSingleObjStar
code: /-- The induced `G`-action on the target of `J : SingleObj G ⥤ Type u`. -/
instance (J : SingleObj M ⥤ Type u) : MulAction M (J.obj (SingleObj.star M)) 
goal: MulAction M (J.obj (CategoryTheory.SingleObj.star M))

full_name: CategoryTheory.Limits.SingleObj.Types.sections.equivFixedPoints_apply_coe
code: /-- The equivalence between sections of `J : SingleObj M ⥤ Type u` and fixed points of the
induced action on `J.obj (SingleObj.star M)`. -/
@[simps]
def Types.sections.equivFixedPoints :
    J.sections ≃ MulAction.fixedPoints M (J.obj (SingleObj.star M)) 
goal: ↑((CategoryTheory.Limits.SingleObj.Types.sections.equivFixedPoints J) s) = ↑s (CategoryTheory.SingleObj.star M)

full_name: CategoryTheory.Limits.SingleObj.Types.sections.equivFixedPoints
code: /-- The equivalence between sections of `J : SingleObj M ⥤ Type u` and fixed points of the
induced action on `J.obj (SingleObj.star M)`. -/
@[simps]
def Types.sections.equivFixedPoints :
    J.sections ≃ MulAction.fixedPoints M (J.obj (SingleObj.star M)) 
goal: ↑J.sections ≃ ↑(MulAction.fixedPoints M (J.obj (CategoryTheory.SingleObj.star M)))

full_name: CategoryTheory.Limits.SingleObj.Types.sections.equivFixedPoints_symm_apply_coe
code: /-- The equivalence between sections of `J : SingleObj M ⥤ Type u` and fixed points of the
induced action on `J.obj (SingleObj.star M)`. -/
@[simps]
def Types.sections.equivFixedPoints :
    J.sections ≃ MulAction.fixedPoints M (J.obj (SingleObj.star M)) 
goal: ∀ (x : CategoryTheory.SingleObj M), ↑((CategoryTheory.Limits.SingleObj.Types.sections.equivFixedPoints J).symm p) x = ↑p

full_name: CategoryTheory.Limits.SingleObj.Types.limitEquivFixedPoints_apply_coe
code: /-- The limit of `J : SingleObj M ⥤ Type u` is equivalent to the fixed points of the
induced action on `J.obj (SingleObj.star M)`. -/
@[simps!]
noncomputable def Types.limitEquivFixedPoints :
    limit J ≃ MulAction.fixedPoints M (J.obj (SingleObj.star M)) 
goal: ∀ (a : CategoryTheory.Limits.limit J),
  ↑((CategoryTheory.Limits.SingleObj.Types.limitEquivFixedPoints J) a) =
    CategoryTheory.Limits.limit.π J (CategoryTheory.SingleObj.star M) a

full_name: CategoryTheory.Limits.SingleObj.Types.limitEquivFixedPoints_symm_apply
code: /-- The limit of `J : SingleObj M ⥤ Type u` is equivalent to the fixed points of the
induced action on `J.obj (SingleObj.star M)`. -/
@[simps!]
noncomputable def Types.limitEquivFixedPoints :
    limit J ≃ MulAction.fixedPoints M (J.obj (SingleObj.star M)) 
goal: ∀ (a : ↑(MulAction.fixedPoints M (J.obj (CategoryTheory.SingleObj.star M)))),
  (CategoryTheory.Limits.SingleObj.Types.limitEquivFixedPoints J).symm a =
    (CategoryTheory.Limits.Types.limitEquivSections J).symm
      ((CategoryTheory.Limits.SingleObj.Types.sections.equivFixedPoints J).symm a)

full_name: CategoryTheory.Limits.SingleObj.Types.limitEquivFixedPoints
code: /-- The limit of `J : SingleObj M ⥤ Type u` is equivalent to the fixed points of the
induced action on `J.obj (SingleObj.star M)`. -/
@[simps!]
noncomputable def Types.limitEquivFixedPoints :
    limit J ≃ MulAction.fixedPoints M (J.obj (SingleObj.star M)) 
goal: CategoryTheory.Limits.limit J ≃ ↑(MulAction.fixedPoints M (J.obj (CategoryTheory.SingleObj.star M)))

full_name: CategoryTheory.Limits.SingleObj.Types.Quot.Rel.iff_orbitRel
code: /-- The relation used to construct colimits in types for `J : SingleObj G ⥤ Type u` is
equivalent to the `MulAction.orbitRel` equivalence relation on `J.obj  (SingleObj.star G)`. -/
lemma Types.Quot.Rel.iff_orbitRel (x y : J.obj (SingleObj.star G)) :
    Types.Quot.Rel J ⟨SingleObj.star G, x⟩ ⟨SingleObj.star G, y⟩
    ↔ Setoid.Rel (MulAction.orbitRel G (J.obj (SingleObj.star G))) x y 
goal: CategoryTheory.Limits.Types.Quot.Rel J ⟨CategoryTheory.SingleObj.star G, x⟩ ⟨CategoryTheory.SingleObj.star G, y⟩ ↔
  (MulAction.orbitRel G (J.obj (CategoryTheory.SingleObj.star G))).Rel x y

full_name: CategoryTheory.Limits.SingleObj.Types.Quot.equivOrbitRelQuotient
code: /-- The explicit quotient construction of the colimit of `J : SingleObj G ⥤ Type u` is
equivalent to the quotient of `J.obj (SingleObj.star G)` by the induced action. -/
@[simps]
def Types.Quot.equivOrbitRelQuotient :
    Types.Quot J ≃ MulAction.orbitRel.Quotient G (J.obj (SingleObj.star G)) 
goal: CategoryTheory.Limits.Types.Quot J ≃ MulAction.orbitRel.Quotient G (J.obj (CategoryTheory.SingleObj.star G))

full_name: CategoryTheory.Limits.SingleObj.Types.Quot.equivOrbitRelQuotient_apply
code: /-- The explicit quotient construction of the colimit of `J : SingleObj G ⥤ Type u` is
equivalent to the quotient of `J.obj (SingleObj.star G)` by the induced action. -/
@[simps]
def Types.Quot.equivOrbitRelQuotient :
    Types.Quot J ≃ MulAction.orbitRel.Quotient G (J.obj (SingleObj.star G)) 
goal: (CategoryTheory.Limits.SingleObj.Types.Quot.equivOrbitRelQuotient J) a = Quot.lift (fun p => ⟦p.snd⟧) ⋯ a

full_name: CategoryTheory.Limits.SingleObj.Types.Quot.equivOrbitRelQuotient_symm_apply
code: /-- The explicit quotient construction of the colimit of `J : SingleObj G ⥤ Type u` is
equivalent to the quotient of `J.obj (SingleObj.star G)` by the induced action. -/
@[simps]
def Types.Quot.equivOrbitRelQuotient :
    Types.Quot J ≃ MulAction.orbitRel.Quotient G (J.obj (SingleObj.star G)) 
goal: (CategoryTheory.Limits.SingleObj.Types.Quot.equivOrbitRelQuotient J).symm a =
  Quot.lift (fun x => Quot.mk (CategoryTheory.Limits.Types.Quot.Rel J) ⟨CategoryTheory.SingleObj.star G, x⟩) ⋯ a

full_name: CategoryTheory.Limits.SingleObj.Types.colimitEquivQuotient
code: /-- The colimit of `J : SingleObj G ⥤ Type u` is equivalent to the quotient of
`J.obj (SingleObj.star G)` by the induced action. -/
@[simps!]
noncomputable def Types.colimitEquivQuotient :
    colimit J ≃ MulAction.orbitRel.Quotient G (J.obj (SingleObj.star G)) 
goal: CategoryTheory.Limits.colimit J ≃ MulAction.orbitRel.Quotient G (J.obj (CategoryTheory.SingleObj.star G))

full_name: CategoryTheory.Limits.SingleObj.Types.colimitEquivQuotient_apply
code: /-- The colimit of `J : SingleObj G ⥤ Type u` is equivalent to the quotient of
`J.obj (SingleObj.star G)` by the induced action. -/
@[simps!]
noncomputable def Types.colimitEquivQuotient :
    colimit J ≃ MulAction.orbitRel.Quotient G (J.obj (SingleObj.star G)) 
goal: ∀ (a : CategoryTheory.Limits.colimit J),
  (CategoryTheory.Limits.SingleObj.Types.colimitEquivQuotient J) a =
    Quot.lift (fun p => ⟦p.snd⟧) ⋯ ((CategoryTheory.Limits.Types.colimitEquivQuot J) a)

full_name: CategoryTheory.Limits.SingleObj.Types.colimitEquivQuotient_symm_apply
code: /-- The colimit of `J : SingleObj G ⥤ Type u` is equivalent to the quotient of
`J.obj (SingleObj.star G)` by the induced action. -/
@[simps!]
noncomputable def Types.colimitEquivQuotient :
    colimit J ≃ MulAction.orbitRel.Quotient G (J.obj (SingleObj.star G)) 
goal: ∀ (a : MulAction.orbitRel.Quotient G (J.obj (CategoryTheory.SingleObj.star G))),
  (CategoryTheory.Limits.SingleObj.Types.colimitEquivQuotient J).symm a =
    (CategoryTheory.Limits.Types.colimitEquivQuot J).symm
      (Quot.lift (fun x => Quot.mk (CategoryTheory.Limits.Types.Quot.Rel J) ⟨CategoryTheory.SingleObj.star G, x⟩) ⋯ a)