File: Mathlib/CategoryTheory/Action.lean

full_name: CategoryTheory.actionAsFunctor
code: /-- A multiplicative action M ↻ X viewed as a functor mapping the single object of M to X
  and an element `m : M` to the map `X → X` given by multiplication by `m`. -/
@[simps]
def actionAsFunctor : SingleObj M ⥤ Type u 
goal: CategoryTheory.Functor (CategoryTheory.SingleObj M) (Type u)

full_name: CategoryTheory.actionAsFunctor_obj
code: /-- A multiplicative action M ↻ X viewed as a functor mapping the single object of M to X
  and an element `m : M` to the map `X → X` given by multiplication by `m`. -/
@[simps]
def actionAsFunctor : SingleObj M ⥤ Type u 
goal: ∀ (x : CategoryTheory.SingleObj M), (CategoryTheory.actionAsFunctor M X).obj x = X

full_name: CategoryTheory.actionAsFunctor_map
code: /-- A multiplicative action M ↻ X viewed as a functor mapping the single object of M to X
  and an element `m : M` to the map `X → X` given by multiplication by `m`. -/
@[simps]
def actionAsFunctor : SingleObj M ⥤ Type u 
goal: ∀ {X_1 Y : CategoryTheory.SingleObj M} (x : X_1 ⟶ Y) (x_1 : X), (CategoryTheory.actionAsFunctor M X).map x x_1 = x • x_1

full_name: CategoryTheory.ActionCategory
code: /-- A multiplicative action M ↻ X induces a category structure on X, where a morphism
 from x to y is a scalar taking x to y. Due to implementation details, the object type
 of this category is not equal to X, but is in bijection with X. -/
def ActionCategory 
goal: Type u

full_name: CategoryTheory.instCategoryActionCategory
code: instance : Category (ActionCategory M X) 
goal: CategoryTheory.Category.{u_1, u} (CategoryTheory.ActionCategory M X)

full_name: CategoryTheory.ActionCategory.π
code: /-- The projection from the action category to the monoid, mapping a morphism to its
  label. -/
def π : ActionCategory M X ⥤ SingleObj M 
goal: CategoryTheory.Functor (CategoryTheory.ActionCategory M X) (CategoryTheory.SingleObj M)

full_name: CategoryTheory.ActionCategory.π_map
code: @[simp]
theorem π_map (p q : ActionCategory M X) (f : p ⟶ q) : (π M X).map f = f.val 
goal: (CategoryTheory.ActionCategory.π M X).map f = ↑f

full_name: CategoryTheory.ActionCategory.π_obj
code: @[simp]
theorem π_obj (p : ActionCategory M X) : (π M X).obj p = SingleObj.star M 
goal: (CategoryTheory.ActionCategory.π M X).obj p = CategoryTheory.SingleObj.star M

full_name: CategoryTheory.ActionCategory.back
code: /-- The canonical map `ActionCategory M X → X`. It is given by `fun x => x.snd`, but
  has a more explicit type. -/
protected def back : ActionCategory M X → X 
goal: CategoryTheory.ActionCategory M X → X

full_name: CategoryTheory.ActionCategory.instCoeTC
code: instance : CoeTC X (ActionCategory M X) 
goal: CoeTC X (CategoryTheory.ActionCategory M X)

full_name: CategoryTheory.ActionCategory.coe_back
code: @[simp]
theorem coe_back (x : X) : ActionCategory.back (x : ActionCategory M X) = x 
goal: CategoryTheory.ActionCategory.back ⟨(), x⟩ = x

full_name: CategoryTheory.ActionCategory.back_coe
code: @[simp]
theorem back_coe (x : ActionCategory M X) : ↑x.back = x 
goal: ⟨(), x.back⟩ = x

full_name: CategoryTheory.ActionCategory.objEquiv
code: /-- An object of the action category given by M ↻ X corresponds to an element of X. -/
def objEquiv : X ≃ ActionCategory M X 
goal: X ≃ CategoryTheory.ActionCategory M X

full_name: CategoryTheory.ActionCategory.hom_as_subtype
code: theorem hom_as_subtype (p q : ActionCategory M X) : (p ⟶ q) = { m : M // m • p.back = q.back } 
goal: (p ⟶ q) = { m // m • p.back = q.back }

full_name: CategoryTheory.ActionCategory.instInhabited
code: instance [Inhabited X] : Inhabited (ActionCategory M X) 
goal: Inhabited (CategoryTheory.ActionCategory M X)

full_name: CategoryTheory.ActionCategory.instNonempty
code: instance [Nonempty X] : Nonempty (ActionCategory M X) 
goal: Nonempty (CategoryTheory.ActionCategory M X)

full_name: CategoryTheory.ActionCategory.stabilizerIsoEnd
code: /-- The stabilizer of a point is isomorphic to the endomorphism monoid at the
  corresponding point. In fact they are definitionally equivalent. -/
def stabilizerIsoEnd : stabilizerSubmonoid M x ≃* @End (ActionCategory M X) _ x 
goal: ↥(MulAction.stabilizerSubmonoid M x) ≃* CategoryTheory.End ⟨(), x⟩

full_name: CategoryTheory.ActionCategory.stabilizerIsoEnd_apply
code: @[simp]
theorem stabilizerIsoEnd_apply (f : stabilizerSubmonoid M x) :
    (stabilizerIsoEnd M x) f = f 
goal: (CategoryTheory.ActionCategory.stabilizerIsoEnd M x) f = f

full_name: CategoryTheory.ActionCategory.stabilizerIsoEnd_symm_apply
code: @[simp 1100]
theorem stabilizerIsoEnd_symm_apply (f : End _) : (stabilizerIsoEnd M x).symm f = f 
goal: (CategoryTheory.ActionCategory.stabilizerIsoEnd M x).symm f = f

full_name: CategoryTheory.ActionCategory.id_val
code: @[simp]
protected theorem id_val (x : ActionCategory M X) : Subtype.val (𝟙 x) = 1 
goal: ↑(CategoryTheory.CategoryStruct.id x) = 1

full_name: CategoryTheory.ActionCategory.comp_val
code: @[simp]
protected theorem comp_val {x y z : ActionCategory M X} (f : x ⟶ y) (g : y ⟶ z) :
    (f ≫ g).val = g.val * f.val 
goal: ↑(CategoryTheory.CategoryStruct.comp f g) = ↑g * ↑f

full_name: CategoryTheory.ActionCategory.instIsConnectedOfIsPretransitiveOfNonempty
code: instance [IsPretransitive M X] [Nonempty X] : IsConnected (ActionCategory M X) 
goal: CategoryTheory.IsConnected (CategoryTheory.ActionCategory M X)

full_name: CategoryTheory.ActionCategory.instGroupoid
code: instance : Groupoid (ActionCategory G X) 
goal: CategoryTheory.Groupoid (CategoryTheory.ActionCategory G X)

full_name: CategoryTheory.ActionCategory.endMulEquivSubgroup
code: /-- Any subgroup of `G` is a vertex group in its action groupoid. -/
def endMulEquivSubgroup (H : Subgroup G) : End (objEquiv G (G ⧸ H) ↑(1 : G)) ≃* H 
goal: CategoryTheory.End ((CategoryTheory.ActionCategory.objEquiv G (G ⧸ H)) ↑1) ≃* ↥H

full_name: CategoryTheory.ActionCategory.homOfPair
code: /-- A target vertex `t` and a scalar `g` determine a morphism in the action groupoid. -/
def homOfPair (t : X) (g : G) : @Quiver.Hom (ActionCategory G X) _ (g⁻¹ • t :) t 
goal: ⟨(), g⁻¹ • t⟩ ⟶ ⟨(), t⟩

full_name: CategoryTheory.ActionCategory.homOfPair.val
code: @[simp]
theorem homOfPair.val (t : X) (g : G) : (homOfPair t g).val = g 
goal: ↑(CategoryTheory.ActionCategory.homOfPair t g) = g

full_name: CategoryTheory.ActionCategory.cases
code: /-- Any morphism in the action groupoid is given by some pair. -/
protected def cases {P : ∀ ⦃a b : ActionCategory G X⦄, (a ⟶ b) → Sort*}
    (hyp : ∀ t g, P (homOfPair t g)) ⦃a b⦄ (f : a ⟶ b) : P f 
goal: P f

full_name: CategoryTheory.ActionCategory.cases'
code: lemma cases' ⦃a' b' : ActionCategory G X⦄ (f : a' ⟶ b') :
    ∃ (a b : X) (g : G) (ha : a' = a) (hb : b' = b) (hg : a = g⁻¹ • b),
      f = eqToHom (by rw [ha, hg]) ≫ homOfPair b g ≫ eqToHom (by rw [hb]) 
goal: ∃ a b g,
  ∃ (ha : a' = ⟨(), a⟩) (hb : b' = ⟨(), b⟩) (hg : a = g⁻¹ • b),
    f =
      CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
        (CategoryTheory.CategoryStruct.comp (CategoryTheory.ActionCategory.homOfPair b g) (CategoryTheory.eqToHom ⋯))

full_name: CategoryTheory.ActionCategory.curry
code: /-- Given `G` acting on `X`, a functor from the corresponding action groupoid to a group `H`
    can be curried to a group homomorphism `G →* (X → H) ⋊ G`. -/
@[simps]
def curry (F : ActionCategory G X ⥤ SingleObj H) : G →* (X → H) ⋊[mulAutArrow] G 
goal: G →* (X → H) ⋊[mulAutArrow] G

full_name: CategoryTheory.ActionCategory.curry_apply_left
code: /-- Given `G` acting on `X`, a functor from the corresponding action groupoid to a group `H`
    can be curried to a group homomorphism `G →* (X → H) ⋊ G`. -/
@[simps]
def curry (F : ActionCategory G X ⥤ SingleObj H) : G →* (X → H) ⋊[mulAutArrow] G 
goal: ((CategoryTheory.ActionCategory.curry F) g).left b = F.map (CategoryTheory.ActionCategory.homOfPair b g)

full_name: CategoryTheory.ActionCategory.curry_apply_right
code: /-- Given `G` acting on `X`, a functor from the corresponding action groupoid to a group `H`
    can be curried to a group homomorphism `G →* (X → H) ⋊ G`. -/
@[simps]
def curry (F : ActionCategory G X ⥤ SingleObj H) : G →* (X → H) ⋊[mulAutArrow] G 
goal: ((CategoryTheory.ActionCategory.curry F) g).right = g

full_name: CategoryTheory.ActionCategory.uncurry_obj
code: /-- Given `G` acting on `X`, a group homomorphism `φ : G →* (X → H) ⋊ G` can be uncurried to
    a functor from the action groupoid to `H`, provided that `φ g = (_, g)` for all `g`. -/
@[simps]
def uncurry (F : G →* (X → H) ⋊[mulAutArrow] G) (sane : ∀ g, (F g).right = g) :
    ActionCategory G X ⥤ SingleObj H 
goal: ∀ (x : CategoryTheory.ActionCategory G X), (CategoryTheory.ActionCategory.uncurry F sane).obj x = ()

full_name: CategoryTheory.ActionCategory.uncurry_map
code: /-- Given `G` acting on `X`, a group homomorphism `φ : G →* (X → H) ⋊ G` can be uncurried to
    a functor from the action groupoid to `H`, provided that `φ g = (_, g)` for all `g`. -/
@[simps]
def uncurry (F : G →* (X → H) ⋊[mulAutArrow] G) (sane : ∀ g, (F g).right = g) :
    ActionCategory G X ⥤ SingleObj H 
goal: ∀ {x b : CategoryTheory.ActionCategory G X} (f : x ⟶ b),
  (CategoryTheory.ActionCategory.uncurry F sane).map f = (F ↑f).left b.back

full_name: CategoryTheory.ActionCategory.uncurry
code: /-- Given `G` acting on `X`, a group homomorphism `φ : G →* (X → H) ⋊ G` can be uncurried to
    a functor from the action groupoid to `H`, provided that `φ g = (_, g)` for all `g`. -/
@[simps]
def uncurry (F : G →* (X → H) ⋊[mulAutArrow] G) (sane : ∀ g, (F g).right = g) :
    ActionCategory G X ⥤ SingleObj H 
goal: CategoryTheory.Functor (CategoryTheory.ActionCategory G X) (CategoryTheory.SingleObj H)