l3lab/ntp-mathlib huggingface dataset:
/-- 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 := by
  refine' cast _ (hyp b.back f.val)
  

Proof state:
M : Type u_1
inst✝³ : Monoid M
X : Type u
inst✝² : MulAction M X
x : X
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G X
P : ⦃a b : ActionCategory G X⦄ → (a ⟶ b) → Sort u_3
hyp : (t : X) → (g : G) → P (homOfPair t g)
a b : ActionCategory G X
f : a ⟶ b
⊢ P (homOfPair (ActionCategory.back b) ↑f) = P f

Next tactic:
rcases a with ⟨⟨⟩, a : X⟩
/-- 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 := by
  refine' cast _ (hyp b.back f.val)
  rcases a with ⟨⟨⟩, a : X⟩
  

Proof state:
case mk.unit
M : Type u_1
inst✝³ : Monoid M
X : Type u
inst✝² : MulAction M X
x : X
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G X
P : ⦃a b : ActionCategory G X⦄ → (a ⟶ b) → Sort u_3
hyp : (t : X) → (g : G) → P (homOfPair t g)
b : ActionCategory G X
a : X
f : { fst := PUnit.unit, snd := a } ⟶ b
⊢ P (homOfPair (ActionCategory.back b) ↑f) = P f

Next tactic:
rcases b with ⟨⟨⟩, b : X⟩
/-- 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 := by
  refine' cast _ (hyp b.back f.val)
  rcases a with ⟨⟨⟩, a : X⟩
  rcases b with ⟨⟨⟩, b : X⟩
  

Proof state:
case mk.unit.mk.unit
M : Type u_1
inst✝³ : Monoid M
X : Type u
inst✝² : MulAction M X
x : X
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G X
P : ⦃a b : ActionCategory G X⦄ → (a ⟶ b) → Sort u_3
hyp : (t : X) → (g : G) → P (homOfPair t g)
a b : X
f : { fst := PUnit.unit, snd := a } ⟶ { fst := PUnit.unit, snd := b }
⊢ P (homOfPair (ActionCategory.back { fst := PUnit.unit, snd := b }) ↑f) = P f

Next tactic:
rcases f with ⟨g : G, h : g • a = b⟩
/-- 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 := by
  refine' cast _ (hyp b.back f.val)
  rcases a with ⟨⟨⟩, a : X⟩
  rcases b with ⟨⟨⟩, b : X⟩
  rcases f with ⟨g : G, h : g • a = b⟩
  

Proof state:
case mk.unit.mk.unit.mk
M : Type u_1
inst✝³ : Monoid M
X : Type u
inst✝² : MulAction M X
x : X
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G X
P : ⦃a b : ActionCategory G X⦄ → (a ⟶ b) → Sort u_3
hyp : (t : X) → (g : G) → P (homOfPair t g)
a b : X
g : G
h : g • a = b
⊢ P (homOfPair (ActionCategory.back { fst := PUnit.unit, snd := b }) ↑{ val := g, property := h }) =
    P { val := g, property := h }

Next tactic:
cases inv_smul_eq_iff.mpr h.symm
/-- 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 := by
  refine' cast _ (hyp b.back f.val)
  rcases a with ⟨⟨⟩, a : X⟩
  rcases b with ⟨⟨⟩, b : X⟩
  rcases f with ⟨g : G, h : g • a = b⟩
  cases inv_smul_eq_iff.mpr h.symm
  

Proof state:
case mk.unit.mk.unit.mk.refl
M : Type u_1
inst✝³ : Monoid M
X : Type u
inst✝² : MulAction M X
x : X
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G X
P : ⦃a b : ActionCategory G X⦄ → (a ⟶ b) → Sort u_3
hyp : (t : X) → (g : G) → P (homOfPair t g)
b : X
g : G
h : g • g⁻¹ • b = b
⊢ P (homOfPair (ActionCategory.back { fst := PUnit.unit, snd := b }) ↑{ val := g, property := h }) =
    P { val := g, property := h }

Next tactic:
rfl
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 

Proof state:
M : Type u_1
inst✝³ : Monoid M
X : Type u
inst✝² : MulAction M X
x : X
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G X
a' b' : ActionCategory G X
f : a' ⟶ b'
a b : X
g : G
ha : a' = { fst := (), snd := a }
hb : b' = { fst := (), snd := b }
hg : a = g⁻¹ • b
⊢ a' = { fst := (), snd := g⁻¹ • b }

Next tactic:
rw [ha, hg]
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 

Proof state:
M : Type u_1
inst✝³ : Monoid M
X : Type u
inst✝² : MulAction M X
x : X
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G X
a' b' : ActionCategory G X
f : a' ⟶ b'
a b : X
g : G
ha : a' = { fst := (), snd := a }
hb : b' = { fst := (), snd := b }
hg : a = g⁻¹ • b
⊢ { fst := (), snd := b } = b'

Next tactic:
rw [hb]
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]) := by
  

Proof state:
M : Type u_1
inst✝³ : Monoid M
X : Type u
inst✝² : MulAction M X
x : X
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G X
a' b' : ActionCategory G X
f : a' ⟶ b'
⊢ ∃ a b g,
    ∃ (ha : a' = { fst := (), snd := a }) (hb : b' = { fst := (), snd := b }) (hg : a = g⁻¹ • b),
      f = eqToHom (_ : a' = { fst := (), snd := g⁻¹ • b }) ≫ homOfPair b g ≫ eqToHom (_ : { fst := (), snd := b } = b')

Next tactic:
revert a' b' f
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]) := by
  revert a' b' f
  

Proof state:
M : Type u_1
inst✝³ : Monoid M
X : Type u
inst✝² : MulAction M X
x : X
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G X
⊢ ∀ ⦃a' b' : ActionCategory G X⦄ (f : a' ⟶ b'),
    ∃ a b g,
      ∃ (ha : a' = { fst := (), snd := a }) (hb : b' = { fst := (), snd := b }) (hg : a = g⁻¹ • b),
        f =
          eqToHom (_ : a' = { fst := (), snd := g⁻¹ • b }) ≫ homOfPair b g ≫ eqToHom (_ : { fst := (), snd := b } = b')

Next tactic:
exact ActionCategory.cases (fun t g => ⟨g⁻¹ • t, t, g, rfl, rfl, rfl, by simp⟩)
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]) := by
  revert a' b' f
  exact ActionCategory.cases (fun t g => ⟨g⁻¹ • t, t, g, rfl, rfl, rfl, by 

Proof state:
M : Type u_1
inst✝³ : Monoid M
X : Type u
inst✝² : MulAction M X
x : X
G : Type u_2
inst✝¹ : Group G
inst✝ : MulAction G X
t : X
g : G
⊢ homOfPair t g =
    eqToHom (_ : { fst := (), snd := g⁻¹ • t } = { fst := (), snd := g⁻¹ • t }) ≫
      homOfPair t g ≫ eqToHom (_ : { fst := (), snd := t } = { fst := (), snd := t })

Next tactic:
simp
/-- 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 :=
  have F_map_eq : ∀ {a b} {f : a ⟶ b}, F.map f = (F.map (homOfPair b.back f.val) : H) := by
    

Proof state:
M : Type u_1
inst✝⁴ : Monoid M
X : Type u
inst✝³ : MulAction M X
x : X
G : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G X
H : Type u_3
inst✝ : Group H
F : ActionCategory G X ⥤ SingleObj H
⊢ ∀ {a b : ActionCategory G X} {f : a ⟶ b}, F.map f = F.map (homOfPair (ActionCategory.back b) ↑f)

Next tactic:
apply ActionCategory.cases
/-- 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 :=
  have F_map_eq : ∀ {a b} {f : a ⟶ b}, F.map f = (F.map (homOfPair b.back f.val) : H) := by
    apply ActionCategory.cases
    

Proof state:
case hyp
M : Type u_1
inst✝⁴ : Monoid M
X : Type u
inst✝³ : MulAction M X
x : X
G : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G X
H : Type u_3
inst✝ : Group H
F : ActionCategory G X ⥤ SingleObj H
⊢ ∀ (t : X) (g : G),
    F.map (homOfPair t g) = F.map (homOfPair (ActionCategory.back { fst := (), snd := t }) ↑(homOfPair t g))

Next tactic:
intros
/-- 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 :=
  have F_map_eq : ∀ {a b} {f : a ⟶ b}, F.map f = (F.map (homOfPair b.back f.val) : H) := by
    apply ActionCategory.cases
    intros
    

Proof state:
case hyp
M : Type u_1
inst✝⁴ : Monoid M
X : Type u
inst✝³ : MulAction M X
x : X
G : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G X
H : Type u_3
inst✝ : Group H
F : ActionCategory G X ⥤ SingleObj H
t✝ : X
g✝ : G
⊢ F.map (homOfPair t✝ g✝) = F.map (homOfPair (ActionCategory.back { fst := (), snd := t✝ }) ↑(homOfPair t✝ g✝))

Next tactic:
rfl
/-- 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 :=
  have F_map_eq : ∀ {a b} {f : a ⟶ b}, F.map f = (F.map (homOfPair b.back f.val) : H) := by
    apply ActionCategory.cases
    intros
    rfl
  { toFun := fun g => ⟨fun b => F.map (homOfPair b g), g⟩
    map_one' := by
      

Proof state:
M : Type u_1
inst✝⁴ : Monoid M
X : Type u
inst✝³ : MulAction M X
x : X
G : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G X
H : Type u_3
inst✝ : Group H
F : ActionCategory G X ⥤ SingleObj H
F_map_eq : ∀ {a b : ActionCategory G X} {f : a ⟶ b}, F.map f = F.map (homOfPair (ActionCategory.back b) ↑f)
⊢ (fun g => { left := fun b => F.map (homOfPair b g), right := g }) 1 = 1

Next tactic:
congr
/-- 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 :=
  have F_map_eq : ∀ {a b} {f : a ⟶ b}, F.map f = (F.map (homOfPair b.back f.val) : H) := by
    apply ActionCategory.cases
    intros
    rfl
  { toFun := fun g => ⟨fun b => F.map (homOfPair b g), g⟩
    map_one' := by
      congr
      

Proof state:
M : Type u_1
inst✝⁴ : Monoid M
X : Type u
inst✝³ : MulAction M X
x : X
G : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G X
H : Type u_3
inst✝ : Group H
F : ActionCategory G X ⥤ SingleObj H
F_map_eq : ∀ {a b : ActionCategory G X} {f : a ⟶ b}, F.map f = F.map (homOfPair (ActionCategory.back b) ↑f)
⊢ (fun g => { left := fun b => F.map (homOfPair b g), right := g }) 1 = 1

Next tactic:
dsimp
/-- 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 :=
  have F_map_eq : ∀ {a b} {f : a ⟶ b}, F.map f = (F.map (homOfPair b.back f.val) : H) := by
    apply ActionCategory.cases
    intros
    rfl
  { toFun := fun g => ⟨fun b => F.map (homOfPair b g), g⟩
    map_one' := by
      congr
      dsimp
      

Proof state:
M : Type u_1
inst✝⁴ : Monoid M
X : Type u
inst✝³ : MulAction M X
x : X
G : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G X
H : Type u_3
inst✝ : Group H
F : ActionCategory G X ⥤ SingleObj H
F_map_eq : ∀ {a b : ActionCategory G X} {f : a ⟶ b}, F.map f = F.map (homOfPair (ActionCategory.back b) ↑f)
⊢ { left := fun b => F.map (homOfPair b 1), right := 1 } = 1

Next tactic:
ext1
/-- 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 :=
  have F_map_eq : ∀ {a b} {f : a ⟶ b}, F.map f = (F.map (homOfPair b.back f.val) : H) := by
    apply ActionCategory.cases
    intros
    rfl
  { toFun := fun g => ⟨fun b => F.map (homOfPair b g), g⟩
    map_one' := by
      congr
      dsimp
      ext1
      

Proof state:
case left
M : Type u_1
inst✝⁴ : Monoid M
X : Type u
inst✝³ : MulAction M X
x : X
G : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G X
H : Type u_3
inst✝ : Group H
F : ActionCategory G X ⥤ SingleObj H
F_map_eq : ∀ {a b : ActionCategory G X} {f : a ⟶ b}, F.map f = F.map (homOfPair (ActionCategory.back b) ↑f)
⊢ { left := fun b => F.map (homOfPair b 1), right := 1 }.left = 1.left
case right
M : Type u_1
inst✝⁴ : Monoid M
X : Type u
inst✝³ : MulAction M X
x : X
G : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G X
H : Type u_3
inst✝ : Group H
F : ActionCategory G X ⥤ SingleObj H
F_map_eq : ∀ {a b : ActionCategory G X} {f : a ⟶ b}, F.map f = F.map (homOfPair (ActionCategory.back b) ↑f)
⊢ { left := fun b => F.map (homOfPair b 1), right := 1 }.right = 1.right

Next tactic:
ext b
/-- 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 :=
  have F_map_eq : ∀ {a b} {f : a ⟶ b}, F.map f = (F.map (homOfPair b.back f.val) : H) := by
    apply ActionCategory.cases
    intros
    rfl
  { toFun := fun g => ⟨fun b => F.map (homOfPair b g), g⟩
    map_one' := by
      congr
      dsimp
      ext1
      ext b
      

Proof state:
case left.h
M : Type u_1
inst✝⁴ : Monoid M
X : Type u
inst✝³ : MulAction M X
x : X
G : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G X
H : Type u_3
inst✝ : Group H
F : ActionCategory G X ⥤ SingleObj H
F_map_eq : ∀ {a b : ActionCategory G X} {f : a ⟶ b}, F.map f = F.map (homOfPair (ActionCategory.back b) ↑f)
b : X
⊢ left { left := fun b => F.map (homOfPair b 1), right := 1 } b = left 1 b
case right
M : Type u_1
inst✝⁴ : Monoid M
X : Type u
inst✝³ : MulAction M X
x : X
G : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G X
H : Type u_3
inst✝ : Group H
F : ActionCategory G X ⥤ SingleObj H
F_map_eq : ∀ {a b : ActionCategory G X} {f : a ⟶ b}, F.map f = F.map (homOfPair (ActionCategory.back b) ↑f)
⊢ { left := fun b => F.map (homOfPair b 1), right := 1 }.right = 1.right

Next tactic:
exact F_map_eq.symm.trans (F.map_id b)
/-- 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 :=
  have F_map_eq : ∀ {a b} {f : a ⟶ b}, F.map f = (F.map (homOfPair b.back f.val) : H) := by
    apply ActionCategory.cases
    intros
    rfl
  { toFun := fun g => ⟨fun b => F.map (homOfPair b g), g⟩
    map_one' := by
      congr
      dsimp
      ext1
      ext b
      exact F_map_eq.symm.trans (F.map_id b)
      

Proof state:
case right
M : Type u_1
inst✝⁴ : Monoid M
X : Type u
inst✝³ : MulAction M X
x : X
G : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G X
H : Type u_3
inst✝ : Group H
F : ActionCategory G X ⥤ SingleObj H
F_map_eq : ∀ {a b : ActionCategory G X} {f : a ⟶ b}, F.map f = F.map (homOfPair (ActionCategory.back b) ↑f)
⊢ { left := fun b => F.map (homOfPair b 1), right := 1 }.right = 1.right

Next tactic:
rfl
/-- 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 :=
  have F_map_eq : ∀ {a b} {f : a ⟶ b}, F.map f = (F.map (homOfPair b.back f.val) : H) := by
    apply ActionCategory.cases
    intros
    rfl
  { toFun := fun g => ⟨fun b => F.map (homOfPair b g), g⟩
    map_one' := by
      congr
      dsimp
      ext1
      ext b
      exact F_map_eq.symm.trans (F.map_id b)
      rfl
    map_mul' := by
      

Proof state:
M : Type u_1
inst✝⁴ : Monoid M
X : Type u
inst✝³ : MulAction M X
x : X
G : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G X
H : Type u_3
inst✝ : Group H
F : ActionCategory G X ⥤ SingleObj H
F_map_eq : ∀ {a b : ActionCategory G X} {f : a ⟶ b}, F.map f = F.map (homOfPair (ActionCategory.back b) ↑f)
⊢ ∀ (x y : G),
    OneHom.toFun
        { toFun := fun g => { left := fun b => F.map (homOfPair b g), right := g },
          map_one' := (_ : (fun g => { left := fun b => F.map (homOfPair b g), right := g }) 1 = 1) }
        (x * y) =
      OneHom.toFun
          { toFun := fun g => { left := fun b => F.map (homOfPair b g), right := g },
            map_one' := (_ : (fun g => { left := fun b => F.map (homOfPair b g), right := g }) 1 = 1) }
          x *
        OneHom.toFun
          { toFun := fun g => { left := fun b => F.map (homOfPair b g), right := g },
            map_one' := (_ : (fun g => { left := fun b => F.map (homOfPair b g), right := g }) 1 = 1) }
          y

Next tactic:
intro g h
/-- 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 :=
  have F_map_eq : ∀ {a b} {f : a ⟶ b}, F.map f = (F.map (homOfPair b.back f.val) : H) := by
    apply ActionCategory.cases
    intros
    rfl
  { toFun := fun g => ⟨fun b => F.map (homOfPair b g), g⟩
    map_one' := by
      congr
      dsimp
      ext1
      ext b
      exact F_map_eq.symm.trans (F.map_id b)
      rfl
    map_mul' := by
      intro g h
      

Proof state:
M : Type u_1
inst✝⁴ : Monoid M
X : Type u
inst✝³ : MulAction M X
x : X
G : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G X
H : Type u_3
inst✝ : Group H
F : ActionCategory G X ⥤ SingleObj H
F_map_eq : ∀ {a b : ActionCategory G X} {f : a ⟶ b}, F.map f = F.map (homOfPair (ActionCategory.back b) ↑f)
g h : G
⊢ OneHom.toFun
      { toFun := fun g => { left := fun b => F.map (homOfPair b g), right := g },
        map_one' := (_ : (fun g => { left := fun b => F.map (homOfPair b g), right := g }) 1 = 1) }
      (g * h) =
    OneHom.toFun
        { toFun := fun g => { left := fun b => F.map (homOfPair b g), right := g },
          map_one' := (_ : (fun g => { left := fun b => F.map (homOfPair b g), right := g }) 1 = 1) }
        g *
      OneHom.toFun
        { toFun := fun g => { left := fun b => F.map (homOfPair b g), right := g },
          map_one' := (_ : (fun g => { left := fun b => F.map (homOfPair b g), right := g }) 1 = 1) }
        h

Next tactic:
congr
/-- 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 :=
  have F_map_eq : ∀ {a b} {f : a ⟶ b}, F.map f = (F.map (homOfPair b.back f.val) : H) := by
    apply ActionCategory.cases
    intros
    rfl
  { toFun := fun g => ⟨fun b => F.map (homOfPair b g), g⟩
    map_one' := by
      congr
      dsimp
      ext1
      ext b
      exact F_map_eq.symm.trans (F.map_id b)
      rfl
    map_mul' := by
      intro g h
      congr
      

Proof state:
M : Type u_1
inst✝⁴ : Monoid M
X : Type u
inst✝³ : MulAction M X
x : X
G : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G X
H : Type u_3
inst✝ : Group H
F : ActionCategory G X ⥤ SingleObj H
F_map_eq : ∀ {a b : ActionCategory G X} {f : a ⟶ b}, F.map f = F.map (homOfPair (ActionCategory.back b) ↑f)
g h : G
⊢ OneHom.toFun
      { toFun := fun g => { left := fun b => F.map (homOfPair b g), right := g },
        map_one' := (_ : (fun g => { left := fun b => F.map (homOfPair b g), right := g }) 1 = 1) }
      (g * h) =
    OneHom.toFun
        { toFun := fun g => { left := fun b => F.map (homOfPair b g), right := g },
          map_one' := (_ : (fun g => { left := fun b => F.map (homOfPair b g), right := g }) 1 = 1) }
        g *
      OneHom.toFun
        { toFun := fun g => { left := fun b => F.map (homOfPair b g), right := g },
          map_one' := (_ : (fun g => { left := fun b => F.map (homOfPair b g), right := g }) 1 = 1) }
        h

Next tactic:
ext b
/-- 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 :=
  have F_map_eq : ∀ {a b} {f : a ⟶ b}, F.map f = (F.map (homOfPair b.back f.val) : H) := by
    apply ActionCategory.cases
    intros
    rfl
  { toFun := fun g => ⟨fun b => F.map (homOfPair b g), g⟩
    map_one' := by
      congr
      dsimp
      ext1
      ext b
      exact F_map_eq.symm.trans (F.map_id b)
      rfl
    map_mul' := by
      intro g h
      congr
      ext b
      

Proof state:
case left.h
M : Type u_1
inst✝⁴ : Monoid M
X : Type u
inst✝³ : MulAction M X
x : X
G : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G X
H : Type u_3
inst✝ : Group H
F : ActionCategory G X ⥤ SingleObj H
F_map_eq : ∀ {a b : ActionCategory G X} {f : a ⟶ b}, F.map f = F.map (homOfPair (ActionCategory.back b) ↑f)
g h : G
b : X
⊢ left
      (OneHom.toFun
        { toFun := fun g => { left := fun b => F.map (homOfPair b g), right := g },
          map_one' := (_ : (fun g => { left := fun b => F.map (homOfPair b g), right := g }) 1 = 1) }
        (g * h))
      b =
    left
      (OneHom.toFun
          { toFun := fun g => { left := fun b => F.map (homOfPair b g), right := g },
            map_one' := (_ : (fun g => { left := fun b => F.map (homOfPair b g), right := g }) 1 = 1) }
          g *
        OneHom.toFun
          { toFun := fun g => { left := fun b => F.map (homOfPair b g), right := g },
            map_one' := (_ : (fun g => { left := fun b => F.map (homOfPair b g), right := g }) 1 = 1) }
          h)
      b
case right
M : Type u_1
inst✝⁴ : Monoid M
X : Type u
inst✝³ : MulAction M X
x : X
G : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G X
H : Type u_3
inst✝ : Group H
F : ActionCategory G X ⥤ SingleObj H
F_map_eq : ∀ {a b : ActionCategory G X} {f : a ⟶ b}, F.map f = F.map (homOfPair (ActionCategory.back b) ↑f)
g h : G
⊢ (OneHom.toFun
        { toFun := fun g => { left := fun b => F.map (homOfPair b g), right := g },
          map_one' := (_ : (fun g => { left := fun b => F.map (homOfPair b g), right := g }) 1 = 1) }
        (g * h)).right =
    (OneHom.toFun
          { toFun := fun g => { left := fun b => F.map (homOfPair b g), right := g },
            map_one' := (_ : (fun g => { left := fun b => F.map (homOfPair b g), right := g }) 1 = 1) }
          g *
        OneHom.toFun
          { toFun := fun g => { left := fun b => F.map (homOfPair b g), right := g },
            map_one' := (_ : (fun g => { left := fun b => F.map (homOfPair b g), right := g }) 1 = 1) }
          h).right

Next tactic:
exact F_map_eq.symm.trans (F.map_comp (homOfPair (g⁻¹ • b) h) (homOfPair b g))