l3lab/ntp-mathlib huggingface dataset:
/-- Actions/representations of the trivial group are just objects in the ambient category. -/
def actionPunitEquivalence : Action V (MonCat.of PUnit) ≌ V where
  functor := forget V _
  inverse :=
    { obj := fun X => ⟨X, 1⟩
      map := fun f => ⟨f, fun ⟨⟩ => by simp⟩ }
  unitIso :=
    NatIso.ofComponents fun X => mkIso (Iso.refl _) fun ⟨⟩ => by
      simp only [MonCat.oneHom_apply, MonCat.one_of, End.one_def, id_eq, Functor.comp_obj,
        forget_obj, Iso.refl_hom, Category.comp_id]
      

Proof state:
V : Type (u + 1)
inst✝ : LargeCategory V
G : MonCat
X : Action V (MonCat.of PUnit.{u + 1})
x✝ : ↑(MonCat.of PUnit.{u + 1})
⊢ ((𝟭 (Action V (MonCat.of PUnit.{u + 1}))).obj X).ρ PUnit.unit = 𝟙 ((𝟭 (Action V (MonCat.of PUnit.{u + 1}))).obj X).V

Next tactic:
exact ρ_one X
/-- Bundles a type `H` with a multiplicative action of `G` as an `Action`. -/
def ofMulAction (G H : Type u) [Monoid G] [MulAction G H] : Action (Type u) (MonCat.of G) where
  V := H
  ρ := @MulAction.toEndHom _ _ _ (by 

Proof state:
V : Type (u + 1)
inst✝² : LargeCategory V
G✝ : MonCat
G H : Type u
inst✝¹ : Monoid G
inst✝ : MulAction G H
⊢ MulAction (↑(MonCat.of G)) H

Next tactic:
assumption
/-- Given a family `F` of types with `G`-actions, this is the limit cone demonstrating that the
product of `F` as types is a product in the category of `G`-sets. -/
def ofMulActionLimitCone {ι : Type v} (G : Type max v u) [Monoid G] (F : ι → Type max v u)
    [∀ i : ι, MulAction G (F i)] :
    LimitCone (Discrete.functor fun i : ι => Action.ofMulAction G (F i)) where
  cone :=
    { pt := Action.ofMulAction G (∀ i : ι, F i)
      π := Discrete.natTrans (fun i => ⟨fun x => x i.as, fun g => rfl⟩) }
  isLimit :=
    { lift := fun s =>
        { hom := fun x i => (s.π.app ⟨i⟩).hom x
          comm := fun g => by
            

Proof state:
V : Type (u + 1)
inst✝² : LargeCategory V
G✝ : MonCat
ι : Type v
G : Type (max v u)
inst✝¹ : Monoid G
F : ι → Type (max v u)
inst✝ : (i : ι) → MulAction G (F i)
s : Cone (Discrete.functor fun i => ofMulAction G (F i))
g : ↑(MonCat.of G)
⊢ (s.pt.ρ g ≫ fun x i => Hom.hom (s.π.app { as := i }) x) =
    (fun x i => Hom.hom (s.π.app { as := i }) x) ≫
      { pt := ofMulAction G ((i : ι) → F i), π := Discrete.natTrans fun i => Hom.mk fun x => x i.as }.pt.ρ g

Next tactic:
ext x
/-- Given a family `F` of types with `G`-actions, this is the limit cone demonstrating that the
product of `F` as types is a product in the category of `G`-sets. -/
def ofMulActionLimitCone {ι : Type v} (G : Type max v u) [Monoid G] (F : ι → Type max v u)
    [∀ i : ι, MulAction G (F i)] :
    LimitCone (Discrete.functor fun i : ι => Action.ofMulAction G (F i)) where
  cone :=
    { pt := Action.ofMulAction G (∀ i : ι, F i)
      π := Discrete.natTrans (fun i => ⟨fun x => x i.as, fun g => rfl⟩) }
  isLimit :=
    { lift := fun s =>
        { hom := fun x i => (s.π.app ⟨i⟩).hom x
          comm := fun g => by
            ext x
            

Proof state:
case h
V : Type (u + 1)
inst✝² : LargeCategory V
G✝ : MonCat
ι : Type v
G : Type (max v u)
inst✝¹ : Monoid G
F : ι → Type (max v u)
inst✝ : (i : ι) → MulAction G (F i)
s : Cone (Discrete.functor fun i => ofMulAction G (F i))
g : ↑(MonCat.of G)
x : s.pt.V
⊢ (s.pt.ρ g ≫ fun x i => Hom.hom (s.π.app { as := i }) x) x =
    ((fun x i => Hom.hom (s.π.app { as := i }) x) ≫
        { pt := ofMulAction G ((i : ι) → F i), π := Discrete.natTrans fun i => Hom.mk fun x => x i.as }.pt.ρ g)
      x

Next tactic:
funext j
/-- Given a family `F` of types with `G`-actions, this is the limit cone demonstrating that the
product of `F` as types is a product in the category of `G`-sets. -/
def ofMulActionLimitCone {ι : Type v} (G : Type max v u) [Monoid G] (F : ι → Type max v u)
    [∀ i : ι, MulAction G (F i)] :
    LimitCone (Discrete.functor fun i : ι => Action.ofMulAction G (F i)) where
  cone :=
    { pt := Action.ofMulAction G (∀ i : ι, F i)
      π := Discrete.natTrans (fun i => ⟨fun x => x i.as, fun g => rfl⟩) }
  isLimit :=
    { lift := fun s =>
        { hom := fun x i => (s.π.app ⟨i⟩).hom x
          comm := fun g => by
            ext x
            funext j
            

Proof state:
case h.h
V : Type (u + 1)
inst✝² : LargeCategory V
G✝ : MonCat
ι : Type v
G : Type (max v u)
inst✝¹ : Monoid G
F : ι → Type (max v u)
inst✝ : (i : ι) → MulAction G (F i)
s : Cone (Discrete.functor fun i => ofMulAction G (F i))
g : ↑(MonCat.of G)
x : s.pt.V
j : ι
⊢ (s.pt.ρ g ≫ fun x i => Hom.hom (s.π.app { as := i }) x) x j =
    ((fun x i => Hom.hom (s.π.app { as := i }) x) ≫
        { pt := ofMulAction G ((i : ι) → F i), π := Discrete.natTrans fun i => Hom.mk fun x => x i.as }.pt.ρ g)
      x j

Next tactic:
exact congr_fun ((s.π.app ⟨j⟩).comm g) x
/-- Given a family `F` of types with `G`-actions, this is the limit cone demonstrating that the
product of `F` as types is a product in the category of `G`-sets. -/
def ofMulActionLimitCone {ι : Type v} (G : Type max v u) [Monoid G] (F : ι → Type max v u)
    [∀ i : ι, MulAction G (F i)] :
    LimitCone (Discrete.functor fun i : ι => Action.ofMulAction G (F i)) where
  cone :=
    { pt := Action.ofMulAction G (∀ i : ι, F i)
      π := Discrete.natTrans (fun i => ⟨fun x => x i.as, fun g => rfl⟩) }
  isLimit :=
    { lift := fun s =>
        { hom := fun x i => (s.π.app ⟨i⟩).hom x
          comm := fun g => by
            ext x
            funext j
            exact congr_fun ((s.π.app ⟨j⟩).comm g) x }
      fac := fun s j => rfl
      uniq := fun s f h => by
        

Proof state:
V : Type (u + 1)
inst✝² : LargeCategory V
G✝ : MonCat
ι : Type v
G : Type (max v u)
inst✝¹ : Monoid G
F : ι → Type (max v u)
inst✝ : (i : ι) → MulAction G (F i)
s : Cone (Discrete.functor fun i => ofMulAction G (F i))
f : s.pt ⟶ { pt := ofMulAction G ((i : ι) → F i), π := Discrete.natTrans fun i => Hom.mk fun x => x i.as }.pt
h :
  ∀ (j : Discrete ι),
    f ≫ { pt := ofMulAction G ((i : ι) → F i), π := Discrete.natTrans fun i => Hom.mk fun x => x i.as }.π.app j =
      s.π.app j
⊢ f = (fun s => Hom.mk fun x i => Hom.hom (s.π.app { as := i }) x) s

Next tactic:
ext x
/-- Given a family `F` of types with `G`-actions, this is the limit cone demonstrating that the
product of `F` as types is a product in the category of `G`-sets. -/
def ofMulActionLimitCone {ι : Type v} (G : Type max v u) [Monoid G] (F : ι → Type max v u)
    [∀ i : ι, MulAction G (F i)] :
    LimitCone (Discrete.functor fun i : ι => Action.ofMulAction G (F i)) where
  cone :=
    { pt := Action.ofMulAction G (∀ i : ι, F i)
      π := Discrete.natTrans (fun i => ⟨fun x => x i.as, fun g => rfl⟩) }
  isLimit :=
    { lift := fun s =>
        { hom := fun x i => (s.π.app ⟨i⟩).hom x
          comm := fun g => by
            ext x
            funext j
            exact congr_fun ((s.π.app ⟨j⟩).comm g) x }
      fac := fun s j => rfl
      uniq := fun s f h => by
        ext x
        

Proof state:
case h.h
V : Type (u + 1)
inst✝² : LargeCategory V
G✝ : MonCat
ι : Type v
G : Type (max v u)
inst✝¹ : Monoid G
F : ι → Type (max v u)
inst✝ : (i : ι) → MulAction G (F i)
s : Cone (Discrete.functor fun i => ofMulAction G (F i))
f : s.pt ⟶ { pt := ofMulAction G ((i : ι) → F i), π := Discrete.natTrans fun i => Hom.mk fun x => x i.as }.pt
h :
  ∀ (j : Discrete ι),
    f ≫ { pt := ofMulAction G ((i : ι) → F i), π := Discrete.natTrans fun i => Hom.mk fun x => x i.as }.π.app j =
      s.π.app j
x : s.pt.V
⊢ Hom.hom f x = Hom.hom ((fun s => Hom.mk fun x i => Hom.hom (s.π.app { as := i }) x) s) x

Next tactic:
funext j
/-- Given a family `F` of types with `G`-actions, this is the limit cone demonstrating that the
product of `F` as types is a product in the category of `G`-sets. -/
def ofMulActionLimitCone {ι : Type v} (G : Type max v u) [Monoid G] (F : ι → Type max v u)
    [∀ i : ι, MulAction G (F i)] :
    LimitCone (Discrete.functor fun i : ι => Action.ofMulAction G (F i)) where
  cone :=
    { pt := Action.ofMulAction G (∀ i : ι, F i)
      π := Discrete.natTrans (fun i => ⟨fun x => x i.as, fun g => rfl⟩) }
  isLimit :=
    { lift := fun s =>
        { hom := fun x i => (s.π.app ⟨i⟩).hom x
          comm := fun g => by
            ext x
            funext j
            exact congr_fun ((s.π.app ⟨j⟩).comm g) x }
      fac := fun s j => rfl
      uniq := fun s f h => by
        ext x
        funext j
        

Proof state:
case h.h.h
V : Type (u + 1)
inst✝² : LargeCategory V
G✝ : MonCat
ι : Type v
G : Type (max v u)
inst✝¹ : Monoid G
F : ι → Type (max v u)
inst✝ : (i : ι) → MulAction G (F i)
s : Cone (Discrete.functor fun i => ofMulAction G (F i))
f : s.pt ⟶ { pt := ofMulAction G ((i : ι) → F i), π := Discrete.natTrans fun i => Hom.mk fun x => x i.as }.pt
h :
  ∀ (j : Discrete ι),
    f ≫ { pt := ofMulAction G ((i : ι) → F i), π := Discrete.natTrans fun i => Hom.mk fun x => x i.as }.π.app j =
      s.π.app j
x : s.pt.V
j : ι
⊢ Hom.hom f x j = Hom.hom ((fun s => Hom.mk fun x i => Hom.hom (s.π.app { as := i }) x) s) x j

Next tactic:
dsimp at *
/-- Given a family `F` of types with `G`-actions, this is the limit cone demonstrating that the
product of `F` as types is a product in the category of `G`-sets. -/
def ofMulActionLimitCone {ι : Type v} (G : Type max v u) [Monoid G] (F : ι → Type max v u)
    [∀ i : ι, MulAction G (F i)] :
    LimitCone (Discrete.functor fun i : ι => Action.ofMulAction G (F i)) where
  cone :=
    { pt := Action.ofMulAction G (∀ i : ι, F i)
      π := Discrete.natTrans (fun i => ⟨fun x => x i.as, fun g => rfl⟩) }
  isLimit :=
    { lift := fun s =>
        { hom := fun x i => (s.π.app ⟨i⟩).hom x
          comm := fun g => by
            ext x
            funext j
            exact congr_fun ((s.π.app ⟨j⟩).comm g) x }
      fac := fun s j => rfl
      uniq := fun s f h => by
        ext x
        funext j
        dsimp at *
        

Proof state:
case h.h.h
V : Type (u + 1)
inst✝² : LargeCategory V
G✝ : MonCat
ι : Type v
G : Type (max v u)
inst✝¹ : Monoid G
F : ι → Type (max v u)
inst✝ : (i : ι) → MulAction G (F i)
s : Cone (Discrete.functor fun i => ofMulAction G (F i))
f : s.pt ⟶ { pt := ofMulAction G ((i : ι) → F i), π := Discrete.natTrans fun i => Hom.mk fun x => x i.as }.pt
h : ∀ (j : Discrete ι), (f ≫ Hom.mk fun x => x j.as) = s.π.app j
x : s.pt.V
j : ι
⊢ Hom.hom f x j = Hom.hom (s.π.app { as := j }) x

Next tactic:
rw [← h ⟨j⟩]
/-- Given a family `F` of types with `G`-actions, this is the limit cone demonstrating that the
product of `F` as types is a product in the category of `G`-sets. -/
def ofMulActionLimitCone {ι : Type v} (G : Type max v u) [Monoid G] (F : ι → Type max v u)
    [∀ i : ι, MulAction G (F i)] :
    LimitCone (Discrete.functor fun i : ι => Action.ofMulAction G (F i)) where
  cone :=
    { pt := Action.ofMulAction G (∀ i : ι, F i)
      π := Discrete.natTrans (fun i => ⟨fun x => x i.as, fun g => rfl⟩) }
  isLimit :=
    { lift := fun s =>
        { hom := fun x i => (s.π.app ⟨i⟩).hom x
          comm := fun g => by
            ext x
            funext j
            exact congr_fun ((s.π.app ⟨j⟩).comm g) x }
      fac := fun s j => rfl
      uniq := fun s f h => by
        ext x
        funext j
        dsimp at *
        rw [← h ⟨j⟩]
        

Proof state:
case h.h.h
V : Type (u + 1)
inst✝² : LargeCategory V
G✝ : MonCat
ι : Type v
G : Type (max v u)
inst✝¹ : Monoid G
F : ι → Type (max v u)
inst✝ : (i : ι) → MulAction G (F i)
s : Cone (Discrete.functor fun i => ofMulAction G (F i))
f : s.pt ⟶ { pt := ofMulAction G ((i : ι) → F i), π := Discrete.natTrans fun i => Hom.mk fun x => x i.as }.pt
h : ∀ (j : Discrete ι), (f ≫ Hom.mk fun x => x j.as) = s.π.app j
x : s.pt.V
j : ι
⊢ Hom.hom f x j = Hom.hom (f ≫ Hom.mk fun x => x { as := j }.as) x

Next tactic:
rfl
/-- A functor between categories induces a functor between
the categories of `G`-actions within those categories. -/
@[simps]
def mapAction (F : V ⥤ W) (G : MonCat.{u}) : Action V G ⥤ Action W G where
  obj M :=
    { V := F.obj M.V
      ρ :=
        { toFun := fun g => F.map (M.ρ g)
          map_one' := by 

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
W : Type (u + 1)
inst✝ : LargeCategory W
F : V ⥤ W
G : MonCat
M : Action V G
⊢ (fun g => F.map (M.ρ g)) 1 = 1

Next tactic:
simp only [End.one_def, Action.ρ_one, F.map_id, MonCat.one_of]
/-- A functor between categories induces a functor between
the categories of `G`-actions within those categories. -/
@[simps]
def mapAction (F : V ⥤ W) (G : MonCat.{u}) : Action V G ⥤ Action W G where
  obj M :=
    { V := F.obj M.V
      ρ :=
        { toFun := fun g => F.map (M.ρ g)
          map_one' := by simp only [End.one_def, Action.ρ_one, F.map_id, MonCat.one_of]
          map_mul' := fun g h => by
            

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
W : Type (u + 1)
inst✝ : LargeCategory W
F : V ⥤ W
G : MonCat
M : Action V G
g h : ↑G
⊢ OneHom.toFun { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) } (g * h) =
    OneHom.toFun { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) } g *
      OneHom.toFun { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) } h

Next tactic:
dsimp
/-- A functor between categories induces a functor between
the categories of `G`-actions within those categories. -/
@[simps]
def mapAction (F : V ⥤ W) (G : MonCat.{u}) : Action V G ⥤ Action W G where
  obj M :=
    { V := F.obj M.V
      ρ :=
        { toFun := fun g => F.map (M.ρ g)
          map_one' := by simp only [End.one_def, Action.ρ_one, F.map_id, MonCat.one_of]
          map_mul' := fun g h => by
            dsimp
            

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
W : Type (u + 1)
inst✝ : LargeCategory W
F : V ⥤ W
G : MonCat
M : Action V G
g h : ↑G
⊢ F.map (M.ρ (g * h)) = F.map (M.ρ g) * F.map (M.ρ h)

Next tactic:
rw [map_mul, MonCat.mul_of, End.mul_def, End.mul_def, F.map_comp]
/-- A functor between categories induces a functor between
the categories of `G`-actions within those categories. -/
@[simps]
def mapAction (F : V ⥤ W) (G : MonCat.{u}) : Action V G ⥤ Action W G where
  obj M :=
    { V := F.obj M.V
      ρ :=
        { toFun := fun g => F.map (M.ρ g)
          map_one' := by simp only [End.one_def, Action.ρ_one, F.map_id, MonCat.one_of]
          map_mul' := fun g h => by
            dsimp
            rw [map_mul, MonCat.mul_of, End.mul_def, End.mul_def, F.map_comp] } }
  map f :=
    { hom := F.map f.hom
      comm := fun g => by 

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
W : Type (u + 1)
inst✝ : LargeCategory W
F : V ⥤ W
G : MonCat
X✝ Y✝ : Action V G
f : X✝ ⟶ Y✝
g : ↑G
⊢ ((fun M =>
              { V := F.obj M.V,
                ρ :=
                  { toOneHom := { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) },
                    map_mul' :=
                      (_ :
                        ∀ (g h : ↑G),
                          OneHom.toFun
                              { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) }
                              (g * h) =
                            OneHom.toFun
                                { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) } g *
                              OneHom.toFun
                                { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) }
                                h) } })
            X✝).ρ
        g ≫
      F.map f.hom =
    F.map f.hom ≫
      ((fun M =>
              { V := F.obj M.V,
                ρ :=
                  { toOneHom := { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) },
                    map_mul' :=
                      (_ :
                        ∀ (g h : ↑G),
                          OneHom.toFun
                              { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) }
                              (g * h) =
                            OneHom.toFun
                                { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) } g *
                              OneHom.toFun
                                { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) }
                                h) } })
            Y✝).ρ
        g

Next tactic:
dsimp
/-- A functor between categories induces a functor between
the categories of `G`-actions within those categories. -/
@[simps]
def mapAction (F : V ⥤ W) (G : MonCat.{u}) : Action V G ⥤ Action W G where
  obj M :=
    { V := F.obj M.V
      ρ :=
        { toFun := fun g => F.map (M.ρ g)
          map_one' := by simp only [End.one_def, Action.ρ_one, F.map_id, MonCat.one_of]
          map_mul' := fun g h => by
            dsimp
            rw [map_mul, MonCat.mul_of, End.mul_def, End.mul_def, F.map_comp] } }
  map f :=
    { hom := F.map f.hom
      comm := fun g => by dsimp; 

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
W : Type (u + 1)
inst✝ : LargeCategory W
F : V ⥤ W
G : MonCat
X✝ Y✝ : Action V G
f : X✝ ⟶ Y✝
g : ↑G
⊢ F.map (X✝.ρ g) ≫ F.map f.hom = F.map f.hom ≫ F.map (Y✝.ρ g)

Next tactic:
rw [← F.map_comp, f.comm, F.map_comp]
/-- A functor between categories induces a functor between
the categories of `G`-actions within those categories. -/
@[simps]
def mapAction (F : V ⥤ W) (G : MonCat.{u}) : Action V G ⥤ Action W G where
  obj M :=
    { V := F.obj M.V
      ρ :=
        { toFun := fun g => F.map (M.ρ g)
          map_one' := by simp only [End.one_def, Action.ρ_one, F.map_id, MonCat.one_of]
          map_mul' := fun g h => by
            dsimp
            rw [map_mul, MonCat.mul_of, End.mul_def, End.mul_def, F.map_comp] } }
  map f :=
    { hom := F.map f.hom
      comm := fun g => by dsimp; rw [← F.map_comp, f.comm, F.map_comp] }
  map_id M := by 

Proof state:
V : Type (u + 1)
inst✝¹ : LargeCategory V
W : Type (u + 1)
inst✝ : LargeCategory W
F : V ⥤ W
G : MonCat
M : Action V G
⊢ {
          obj := fun M =>
            { V := F.obj M.V,
              ρ :=
                { toOneHom := { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) },
                  map_mul' :=
                    (_ :
                      ∀ (g h : ↑G),
                        OneHom.toFun
                            { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) }
                            (g * h) =
                          OneHom.toFun
                              { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) } g *
                            OneHom.toFun
                              { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) }
                              h) } },
          map := fun {X Y} f => Action.Hom.mk (F.map f.hom) }.map
      (𝟙 M) =
    𝟙
      ({
            obj := fun M =>
              { V := F.obj M.V,
                ρ :=
                  { toOneHom := { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) },
                    map_mul' :=
                      (_ :
                        ∀ (g h : ↑G),
                          OneHom.toFun
                              { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) }
                              (g * h) =
                            OneHom.toFun
                                { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) } g *
                              OneHom.toFun
                                { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) }
                                h) } },
            map := fun {X Y} f => Action.Hom.mk (F.map f.hom) }.obj
        M)

Next tactic:
ext
/-- A functor between categories induces a functor between
the categories of `G`-actions within those categories. -/
@[simps]
def mapAction (F : V ⥤ W) (G : MonCat.{u}) : Action V G ⥤ Action W G where
  obj M :=
    { V := F.obj M.V
      ρ :=
        { toFun := fun g => F.map (M.ρ g)
          map_one' := by simp only [End.one_def, Action.ρ_one, F.map_id, MonCat.one_of]
          map_mul' := fun g h => by
            dsimp
            rw [map_mul, MonCat.mul_of, End.mul_def, End.mul_def, F.map_comp] } }
  map f :=
    { hom := F.map f.hom
      comm := fun g => by dsimp; rw [← F.map_comp, f.comm, F.map_comp] }
  map_id M := by ext; 

Proof state:
case h
V : Type (u + 1)
inst✝¹ : LargeCategory V
W : Type (u + 1)
inst✝ : LargeCategory W
F : V ⥤ W
G : MonCat
M : Action V G
⊢ ({
            obj := fun M =>
              { V := F.obj M.V,
                ρ :=
                  { toOneHom := { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) },
                    map_mul' :=
                      (_ :
                        ∀ (g h : ↑G),
                          OneHom.toFun
                              { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) }
                              (g * h) =
                            OneHom.toFun
                                { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) } g *
                              OneHom.toFun
                                { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) }
                                h) } },
            map := fun {X Y} f => Action.Hom.mk (F.map f.hom) }.map
        (𝟙 M)).hom =
    (𝟙
        ({
              obj := fun M =>
                { V := F.obj M.V,
                  ρ :=
                    { toOneHom := { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) },
                      map_mul' :=
                        (_ :
                          ∀ (g h : ↑G),
                            OneHom.toFun
                                { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) }
                                (g * h) =
                              OneHom.toFun
                                  { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) }
                                  g *
                                OneHom.toFun
                                  { toFun := fun g => F.map (M.ρ g), map_one' := (_ : F.map (M.ρ 1) = 𝟙 (F.obj M.V)) }
                                  h) } },
              map := fun {X Y} f => Action.Hom.mk (F.map f.hom) }.obj
          M)).hom

Next tactic:
simp only [Action.id_hom, F.map_id]
theorem dense_irrational : Dense { x : ℝ | Irrational x } := by
  

Proof state:
⊢ Dense {x | Irrational x}

Next tactic:
refine' Real.isTopologicalBasis_Ioo_rat.dense_iff.2 _
theorem dense_irrational : Dense { x : ℝ | Irrational x } := by
  refine' Real.isTopologicalBasis_Ioo_rat.dense_iff.2 _
  

Proof state:
⊢ ∀ o ∈ ⋃ a, ⋃ b, ⋃ (_ : a < b), {Ioo ↑a ↑b}, Set.Nonempty o → Set.Nonempty (o ∩ {x | Irrational x})

Next tactic:
simp only [gt_iff_lt, Rat.cast_lt, not_lt, ge_iff_le, Rat.cast_le, mem_iUnion, mem_singleton_iff,
    exists_prop, forall_exists_index, and_imp]
theorem dense_irrational : Dense { x : ℝ | Irrational x } := by
  refine' Real.isTopologicalBasis_Ioo_rat.dense_iff.2 _
  simp only [gt_iff_lt, Rat.cast_lt, not_lt, ge_iff_le, Rat.cast_le, mem_iUnion, mem_singleton_iff,
    exists_prop, forall_exists_index, and_imp]
  

Proof state:
⊢ ∀ (o : Set ℝ) (x x_1 : ℚ), x < x_1 → o = Ioo ↑x ↑x_1 → Set.Nonempty o → Set.Nonempty (o ∩ {x | Irrational x})

Next tactic:
rintro _ a b hlt rfl _
theorem dense_irrational : Dense { x : ℝ | Irrational x } := by
  refine' Real.isTopologicalBasis_Ioo_rat.dense_iff.2 _
  simp only [gt_iff_lt, Rat.cast_lt, not_lt, ge_iff_le, Rat.cast_le, mem_iUnion, mem_singleton_iff,
    exists_prop, forall_exists_index, and_imp]
  rintro _ a b hlt rfl _
  

Proof state:
a b : ℚ
hlt : a < b
a✝ : Set.Nonempty (Ioo ↑a ↑b)
⊢ Set.Nonempty (Ioo ↑a ↑b ∩ {x | Irrational x})

Next tactic:
rw [inter_comm]