ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.CommSq.LiftStruct.op_l
@[simps]
def op {sq : CommSq f i p g} (l : LiftStruct sq) : LiftStruct sq.op 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {A B X Y : C} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {g : B ⟶ Y} {sq : CategoryTheory.CommSq f i p g} (l : sq.LiftStruct)
Goal: l.op.l = l.l.op
-- CategoryTheory.CommSq.LiftStruct.unop_l
@[simps]
def unop {A B X Y : Cᵒᵖ} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {g : B ⟶ Y} {sq : CommSq f i p g}
    (l : LiftStruct sq) : LiftStruct sq.unop 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {A B X Y : Cᵒᵖ} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {g : B ⟶ Y} {sq : CategoryTheory.CommSq f i p g} (l : sq.LiftStruct)
Goal: l.unop.l = l.l.unop
-- CategoryTheory.CommSq.LiftStruct.opEquiv_apply
@[simps]
def opEquiv (sq : CommSq f i p g) : LiftStruct sq ≃ LiftStruct sq.op 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {A B X Y : C} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {g : B ⟶ Y} (sq : CategoryTheory.CommSq f i p g) (l : sq.LiftStruct)
Goal: (CategoryTheory.CommSq.LiftStruct.opEquiv sq) l = l.op
-- CategoryTheory.CommSq.LiftStruct.opEquiv_symm_apply
@[simps]
def opEquiv (sq : CommSq f i p g) : LiftStruct sq ≃ LiftStruct sq.op 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {A B X Y : C} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {g : B ⟶ Y} (sq : CategoryTheory.CommSq f i p g) (l : ⋯.LiftStruct)
Goal: (CategoryTheory.CommSq.LiftStruct.opEquiv sq).symm l = l.unop
-- CategoryTheory.CommSq.HasLift.exists_lift
class HasLift : Prop where
    exists_lift : Nonempty sq.LiftStruct
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {A B X Y : C} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {g : B ⟶ Y} {sq : CategoryTheory.CommSq f i p g} [self : sq.HasLift]
Goal: Nonempty sq.LiftStruct
-- CategoryTheory.CommSq.HasLift.mk'
theorem mk' (l : sq.LiftStruct) : HasLift sq 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {A B X Y : C} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {g : B ⟶ Y} {sq : CategoryTheory.CommSq f i p g} (l : sq.LiftStruct)
Goal: sq.HasLift
-- CategoryTheory.CommSq.HasLift.iff
theorem iff : HasLift sq ↔ Nonempty sq.LiftStruct 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {A B X Y : C} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {g : B ⟶ Y} (sq : CategoryTheory.CommSq f i p g)
Goal: sq.HasLift ↔ Nonempty sq.LiftStruct
-- CategoryTheory.CommSq.HasLift.iff_op
theorem iff_op : HasLift sq ↔ HasLift sq.op 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {A B X Y : C} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {g : B ⟶ Y} (sq : CategoryTheory.CommSq f i p g)
Goal: sq.HasLift ↔ ⋯.HasLift
-- CategoryTheory.CommSq.HasLift.iff_unop
theorem iff_unop {A B X Y : Cᵒᵖ} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {g : B ⟶ Y}
    (sq : CommSq f i p g) : HasLift sq ↔ HasLift sq.unop 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {A B X Y : Cᵒᵖ} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {g : B ⟶ Y} (sq : CategoryTheory.CommSq f i p g)
Goal: sq.HasLift ↔ ⋯.HasLift
-- CategoryTheory.CommSq.fac_left
@[reassoc (attr := simp)]
theorem fac_left [hsq : HasLift sq] : i ≫ sq.lift = f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {A B X Y : C} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {g : B ⟶ Y} (sq : CategoryTheory.CommSq f i p g) [hsq : sq.HasLift]
Goal: CategoryTheory.CategoryStruct.comp i sq.lift = f
-- CategoryTheory.CommSq.fac_right
@[reassoc (attr := simp)]
theorem fac_right [hsq : HasLift sq] : sq.lift ≫ p = g 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {A B X Y : C} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {g : B ⟶ Y} (sq : CategoryTheory.CommSq f i p g) [hsq : sq.HasLift]
Goal: CategoryTheory.CategoryStruct.comp sq.lift p = g
-- CategoryTheory.Balanced.isIso_of_mono_of_epi
class Balanced : Prop where
  isIso_of_mono_of_epi : ∀ {X Y : C} (f : X ⟶ Y) [Mono f] [Epi f], IsIso f
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Balanced C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f] [CategoryTheory.Epi f]
Goal: CategoryTheory.IsIso f
-- CategoryTheory.isIso_of_mono_of_epi
theorem isIso_of_mono_of_epi [Balanced C] {X Y : C} (f : X ⟶ Y) [Mono f] [Epi f] : IsIso f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Balanced C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f] [CategoryTheory.Epi f]
Goal: CategoryTheory.IsIso f
-- CategoryTheory.isIso_iff_mono_and_epi
theorem isIso_iff_mono_and_epi [Balanced C] {X Y : C} (f : X ⟶ Y) : IsIso f ↔ Mono f ∧ Epi f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Balanced C] {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.IsIso f ↔ CategoryTheory.Mono f ∧ CategoryTheory.Epi f
-- CategoryTheory.balanced_opposite
theorem balanced_opposite [Balanced C] : Balanced Cᵒᵖ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Balanced C]
Goal: CategoryTheory.Balanced Cᵒᵖ
-- CategoryTheory.Monoidal.InducingFunctorData.whiskerRight_eq
structure InducingFunctorData [MonoidalCategoryStruct D] (F : D ⥤ C) where
    μIso : ∀ X Y,
    F.obj X ⊗ F.obj Y ≅ F.obj (X ⊗ Y)
  whiskerLeft_eq : ∀ (X : D) {Y₁ Y₂ : D} (f : Y₁ ⟶ Y₂),
    F.map (X ◁ f) = (μIso _ _).inv ≫ (F.obj X ◁ F.map f) ≫ (μIso _ _).hom := by
    aesop_cat
  whiskerRight_eq : ∀ {X₁ X₂ : D} (f : X₁ ⟶ X₂) (Y : D),
    F.map (f ▷ Y) = (μIso _ _).inv ≫ (F.map f ▷ F.obj Y) ≫ (μIso _ _).hom := by
    aesop_cat
  tensorHom_eq : ∀ {X₁ Y₁ X₂ Y₂ : D} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
    F.map (f ⊗ g) = (μIso _ _).inv ≫ (F.map f ⊗ F.map g) ≫ (μIso _ _).hom := by
    aesop_cat
    εIso : 𝟙_ _ ≅ F.obj (𝟙_ _)
  associator_eq : ∀ X Y Z : D,
    F.map (α_ X Y Z).hom =
      (((μIso _ _).symm ≪≫ ((μIso _ _).symm ⊗ .refl _))
        ≪≫ α_ (F.obj X) (F.obj Y) (F.obj Z)
        ≪≫ ((.refl _ ⊗ μIso _ _) ≪≫ μIso _ _)).hom := by
    aesop_cat
  leftUnitor_eq : ∀ X : D,
    F.map (λ_ X).hom =
      (((μIso _ _).symm ≪≫ (εIso.symm ⊗ .refl _)) ≪≫ λ_ (F.obj X)).hom := by
    aesop_cat
  rightUnitor_eq : ∀ X : D,
    F.map (ρ_ X).hom =
      (((μIso _ _).symm ≪≫ (.refl _ ⊗ εIso.symm)) ≪≫ ρ_ (F.obj X)).hom := by
    aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategoryStruct D] {F : D ⥤ C} (self : CategoryTheory.Monoidal.InducingFunctorData F) {X₁ X₂ : D} (f : X₁ ⟶ X₂) (Y : D)
Goal: F.map (f ▷ Y) = (self.μIso X₁ Y).inv ≫ F.map f ▷ F.obj Y ≫ (self.μIso X₂ Y).hom
-- CategoryTheory.Monoidal.InducingFunctorData.whiskerLeft_eq
structure InducingFunctorData [MonoidalCategoryStruct D] (F : D ⥤ C) where
    μIso : ∀ X Y,
    F.obj X ⊗ F.obj Y ≅ F.obj (X ⊗ Y)
  whiskerLeft_eq : ∀ (X : D) {Y₁ Y₂ : D} (f : Y₁ ⟶ Y₂),
    F.map (X ◁ f) = (μIso _ _).inv ≫ (F.obj X ◁ F.map f) ≫ (μIso _ _).hom := by
    aesop_cat
  whiskerRight_eq : ∀ {X₁ X₂ : D} (f : X₁ ⟶ X₂) (Y : D),
    F.map (f ▷ Y) = (μIso _ _).inv ≫ (F.map f ▷ F.obj Y) ≫ (μIso _ _).hom := by
    aesop_cat
  tensorHom_eq : ∀ {X₁ Y₁ X₂ Y₂ : D} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
    F.map (f ⊗ g) = (μIso _ _).inv ≫ (F.map f ⊗ F.map g) ≫ (μIso _ _).hom := by
    aesop_cat
    εIso : 𝟙_ _ ≅ F.obj (𝟙_ _)
  associator_eq : ∀ X Y Z : D,
    F.map (α_ X Y Z).hom =
      (((μIso _ _).symm ≪≫ ((μIso _ _).symm ⊗ .refl _))
        ≪≫ α_ (F.obj X) (F.obj Y) (F.obj Z)
        ≪≫ ((.refl _ ⊗ μIso _ _) ≪≫ μIso _ _)).hom := by
    aesop_cat
  leftUnitor_eq : ∀ X : D,
    F.map (λ_ X).hom =
      (((μIso _ _).symm ≪≫ (εIso.symm ⊗ .refl _)) ≪≫ λ_ (F.obj X)).hom := by
    aesop_cat
  rightUnitor_eq : ∀ X : D,
    F.map (ρ_ X).hom =
      (((μIso _ _).symm ≪≫ (.refl _ ⊗ εIso.symm)) ≪≫ ρ_ (F.obj X)).hom := by
    aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategoryStruct D] {F : D ⥤ C} (self : CategoryTheory.Monoidal.InducingFunctorData F) (X : D) {Y₁ Y₂ : D} (f : Y₁ ⟶ Y₂)
Goal: F.map (X ◁ f) = (self.μIso X Y₁).inv ≫ F.obj X ◁ F.map f ≫ (self.μIso X Y₂).hom
-- CategoryTheory.Monoidal.InducingFunctorData.leftUnitor_eq
structure InducingFunctorData [MonoidalCategoryStruct D] (F : D ⥤ C) where
    μIso : ∀ X Y,
    F.obj X ⊗ F.obj Y ≅ F.obj (X ⊗ Y)
  whiskerLeft_eq : ∀ (X : D) {Y₁ Y₂ : D} (f : Y₁ ⟶ Y₂),
    F.map (X ◁ f) = (μIso _ _).inv ≫ (F.obj X ◁ F.map f) ≫ (μIso _ _).hom := by
    aesop_cat
  whiskerRight_eq : ∀ {X₁ X₂ : D} (f : X₁ ⟶ X₂) (Y : D),
    F.map (f ▷ Y) = (μIso _ _).inv ≫ (F.map f ▷ F.obj Y) ≫ (μIso _ _).hom := by
    aesop_cat
  tensorHom_eq : ∀ {X₁ Y₁ X₂ Y₂ : D} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
    F.map (f ⊗ g) = (μIso _ _).inv ≫ (F.map f ⊗ F.map g) ≫ (μIso _ _).hom := by
    aesop_cat
    εIso : 𝟙_ _ ≅ F.obj (𝟙_ _)
  associator_eq : ∀ X Y Z : D,
    F.map (α_ X Y Z).hom =
      (((μIso _ _).symm ≪≫ ((μIso _ _).symm ⊗ .refl _))
        ≪≫ α_ (F.obj X) (F.obj Y) (F.obj Z)
        ≪≫ ((.refl _ ⊗ μIso _ _) ≪≫ μIso _ _)).hom := by
    aesop_cat
  leftUnitor_eq : ∀ X : D,
    F.map (λ_ X).hom =
      (((μIso _ _).symm ≪≫ (εIso.symm ⊗ .refl _)) ≪≫ λ_ (F.obj X)).hom := by
    aesop_cat
  rightUnitor_eq : ∀ X : D,
    F.map (ρ_ X).hom =
      (((μIso _ _).symm ≪≫ (.refl _ ⊗ εIso.symm)) ≪≫ ρ_ (F.obj X)).hom := by
    aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategoryStruct D] {F : D ⥤ C} (self : CategoryTheory.Monoidal.InducingFunctorData F) (X : D)
Goal: F.map (λ_ X).hom =
  (((self.μIso (𝟙_ D) X).symm ≪≫ (self.εIso.symm ⊗ CategoryTheory.Iso.refl (F.obj X))) ≪≫ λ_ (F.obj X)).hom
-- CategoryTheory.Monoidal.InducingFunctorData.rightUnitor_eq
structure InducingFunctorData [MonoidalCategoryStruct D] (F : D ⥤ C) where
    μIso : ∀ X Y,
    F.obj X ⊗ F.obj Y ≅ F.obj (X ⊗ Y)
  whiskerLeft_eq : ∀ (X : D) {Y₁ Y₂ : D} (f : Y₁ ⟶ Y₂),
    F.map (X ◁ f) = (μIso _ _).inv ≫ (F.obj X ◁ F.map f) ≫ (μIso _ _).hom := by
    aesop_cat
  whiskerRight_eq : ∀ {X₁ X₂ : D} (f : X₁ ⟶ X₂) (Y : D),
    F.map (f ▷ Y) = (μIso _ _).inv ≫ (F.map f ▷ F.obj Y) ≫ (μIso _ _).hom := by
    aesop_cat
  tensorHom_eq : ∀ {X₁ Y₁ X₂ Y₂ : D} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
    F.map (f ⊗ g) = (μIso _ _).inv ≫ (F.map f ⊗ F.map g) ≫ (μIso _ _).hom := by
    aesop_cat
    εIso : 𝟙_ _ ≅ F.obj (𝟙_ _)
  associator_eq : ∀ X Y Z : D,
    F.map (α_ X Y Z).hom =
      (((μIso _ _).symm ≪≫ ((μIso _ _).symm ⊗ .refl _))
        ≪≫ α_ (F.obj X) (F.obj Y) (F.obj Z)
        ≪≫ ((.refl _ ⊗ μIso _ _) ≪≫ μIso _ _)).hom := by
    aesop_cat
  leftUnitor_eq : ∀ X : D,
    F.map (λ_ X).hom =
      (((μIso _ _).symm ≪≫ (εIso.symm ⊗ .refl _)) ≪≫ λ_ (F.obj X)).hom := by
    aesop_cat
  rightUnitor_eq : ∀ X : D,
    F.map (ρ_ X).hom =
      (((μIso _ _).symm ≪≫ (.refl _ ⊗ εIso.symm)) ≪≫ ρ_ (F.obj X)).hom := by
    aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategoryStruct D] {F : D ⥤ C} (self : CategoryTheory.Monoidal.InducingFunctorData F) (X : D)
Goal: F.map (ρ_ X).hom =
  (((self.μIso X (𝟙_ D)).symm ≪≫ (CategoryTheory.Iso.refl (F.obj X) ⊗ self.εIso.symm)) ≪≫ ρ_ (F.obj X)).hom
-- CategoryTheory.Monoidal.InducingFunctorData.associator_eq
structure InducingFunctorData [MonoidalCategoryStruct D] (F : D ⥤ C) where
    μIso : ∀ X Y,
    F.obj X ⊗ F.obj Y ≅ F.obj (X ⊗ Y)
  whiskerLeft_eq : ∀ (X : D) {Y₁ Y₂ : D} (f : Y₁ ⟶ Y₂),
    F.map (X ◁ f) = (μIso _ _).inv ≫ (F.obj X ◁ F.map f) ≫ (μIso _ _).hom := by
    aesop_cat
  whiskerRight_eq : ∀ {X₁ X₂ : D} (f : X₁ ⟶ X₂) (Y : D),
    F.map (f ▷ Y) = (μIso _ _).inv ≫ (F.map f ▷ F.obj Y) ≫ (μIso _ _).hom := by
    aesop_cat
  tensorHom_eq : ∀ {X₁ Y₁ X₂ Y₂ : D} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
    F.map (f ⊗ g) = (μIso _ _).inv ≫ (F.map f ⊗ F.map g) ≫ (μIso _ _).hom := by
    aesop_cat
    εIso : 𝟙_ _ ≅ F.obj (𝟙_ _)
  associator_eq : ∀ X Y Z : D,
    F.map (α_ X Y Z).hom =
      (((μIso _ _).symm ≪≫ ((μIso _ _).symm ⊗ .refl _))
        ≪≫ α_ (F.obj X) (F.obj Y) (F.obj Z)
        ≪≫ ((.refl _ ⊗ μIso _ _) ≪≫ μIso _ _)).hom := by
    aesop_cat
  leftUnitor_eq : ∀ X : D,
    F.map (λ_ X).hom =
      (((μIso _ _).symm ≪≫ (εIso.symm ⊗ .refl _)) ≪≫ λ_ (F.obj X)).hom := by
    aesop_cat
  rightUnitor_eq : ∀ X : D,
    F.map (ρ_ X).hom =
      (((μIso _ _).symm ≪≫ (.refl _ ⊗ εIso.symm)) ≪≫ ρ_ (F.obj X)).hom := by
    aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategoryStruct D] {F : D ⥤ C} (self : CategoryTheory.Monoidal.InducingFunctorData F) (X Y Z : D)
Goal: F.map (α_ X Y Z).hom =
  (((self.μIso (X ⊗ Y) Z).symm ≪≫ ((self.μIso X Y).symm ⊗ CategoryTheory.Iso.refl (F.obj Z))) ≪≫
      α_ (F.obj X) (F.obj Y) (F.obj Z) ≪≫
        (CategoryTheory.Iso.refl (F.obj X) ⊗ self.μIso Y Z) ≪≫ self.μIso X (Y ⊗ Z)).hom
-- CategoryTheory.Monoidal.InducingFunctorData.tensorHom_eq
structure InducingFunctorData [MonoidalCategoryStruct D] (F : D ⥤ C) where
    μIso : ∀ X Y,
    F.obj X ⊗ F.obj Y ≅ F.obj (X ⊗ Y)
  whiskerLeft_eq : ∀ (X : D) {Y₁ Y₂ : D} (f : Y₁ ⟶ Y₂),
    F.map (X ◁ f) = (μIso _ _).inv ≫ (F.obj X ◁ F.map f) ≫ (μIso _ _).hom := by
    aesop_cat
  whiskerRight_eq : ∀ {X₁ X₂ : D} (f : X₁ ⟶ X₂) (Y : D),
    F.map (f ▷ Y) = (μIso _ _).inv ≫ (F.map f ▷ F.obj Y) ≫ (μIso _ _).hom := by
    aesop_cat
  tensorHom_eq : ∀ {X₁ Y₁ X₂ Y₂ : D} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
    F.map (f ⊗ g) = (μIso _ _).inv ≫ (F.map f ⊗ F.map g) ≫ (μIso _ _).hom := by
    aesop_cat
    εIso : 𝟙_ _ ≅ F.obj (𝟙_ _)
  associator_eq : ∀ X Y Z : D,
    F.map (α_ X Y Z).hom =
      (((μIso _ _).symm ≪≫ ((μIso _ _).symm ⊗ .refl _))
        ≪≫ α_ (F.obj X) (F.obj Y) (F.obj Z)
        ≪≫ ((.refl _ ⊗ μIso _ _) ≪≫ μIso _ _)).hom := by
    aesop_cat
  leftUnitor_eq : ∀ X : D,
    F.map (λ_ X).hom =
      (((μIso _ _).symm ≪≫ (εIso.symm ⊗ .refl _)) ≪≫ λ_ (F.obj X)).hom := by
    aesop_cat
  rightUnitor_eq : ∀ X : D,
    F.map (ρ_ X).hom =
      (((μIso _ _).symm ≪≫ (.refl _ ⊗ εIso.symm)) ≪≫ ρ_ (F.obj X)).hom := by
    aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategoryStruct D] {F : D ⥤ C} (self : CategoryTheory.Monoidal.InducingFunctorData F) {X₁ Y₁ X₂ Y₂ : D} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂)
Goal: F.map (f ⊗ g) = (self.μIso X₁ X₂).inv ≫ (F.map f ⊗ F.map g) ≫ (self.μIso Y₁ Y₂).hom
-- CategoryTheory.Monoidal.fromInduced_toLaxMonoidalFunctor_toFunctor
@[simps]
def fromInduced [MonoidalCategoryStruct D] (F : D ⥤ C) [F.Faithful]
    (fData : InducingFunctorData F) :
    letI := induced F fData
    MonoidalFunctor D C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategoryStruct D] (F : D ⥤ C) [F.Faithful] (fData : CategoryTheory.Monoidal.InducingFunctorData F)
Goal: (CategoryTheory.Monoidal.fromInduced F fData).toFunctor = F
-- CategoryTheory.Monoidal.fromInduced_toLaxMonoidalFunctor_μ
@[simps]
def fromInduced [MonoidalCategoryStruct D] (F : D ⥤ C) [F.Faithful]
    (fData : InducingFunctorData F) :
    letI := induced F fData
    MonoidalFunctor D C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategoryStruct D] (F : D ⥤ C) [F.Faithful] (fData : CategoryTheory.Monoidal.InducingFunctorData F) (X Y : D)
Goal: (CategoryTheory.Monoidal.fromInduced F fData).μ X Y = (fData.μIso X Y).hom
-- CategoryTheory.Monoidal.fromInduced_toLaxMonoidalFunctor_ε
@[simps]
def fromInduced [MonoidalCategoryStruct D] (F : D ⥤ C) [F.Faithful]
    (fData : InducingFunctorData F) :
    letI := induced F fData
    MonoidalFunctor D C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategoryStruct D] (F : D ⥤ C) [F.Faithful] (fData : CategoryTheory.Monoidal.InducingFunctorData F)
Goal: (CategoryTheory.Monoidal.fromInduced F fData).ε = fData.εIso.hom
-- CategoryTheory.Monoidal.transportStruct_leftUnitor
@[simps]
def transportStruct (e : C ≌ D) : MonoidalCategoryStruct.{v₂} D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D) (X : D)
Goal: λ_ X =
  e.functor.mapIso
      (((e.unitIso.app (𝟙_ C)).symm ⊗ CategoryTheory.Iso.refl (e.inverse.obj X)) ≪≫ λ_ (e.inverse.obj X)) ≪≫
    e.counitIso.app X
-- CategoryTheory.Monoidal.transportStruct_whiskerLeft
@[simps]
def transportStruct (e : C ≌ D) : MonoidalCategoryStruct.{v₂} D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D) (X : D)
Goal: ∀ (x x_1 : D) (f : x ⟶ x_1), X ◁ f = e.functor.map (e.inverse.obj X ◁ e.inverse.map f)
-- CategoryTheory.Monoidal.transportStruct_rightUnitor
@[simps]
def transportStruct (e : C ≌ D) : MonoidalCategoryStruct.{v₂} D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D) (X : D)
Goal: ρ_ X =
  e.functor.mapIso
      ((CategoryTheory.Iso.refl (e.inverse.obj X) ⊗ (e.unitIso.app (𝟙_ C)).symm) ≪≫ ρ_ (e.inverse.obj X)) ≪≫
    e.counitIso.app X
-- CategoryTheory.Monoidal.transportStruct_tensorUnit
@[simps]
def transportStruct (e : C ≌ D) : MonoidalCategoryStruct.{v₂} D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: 𝟙_ D = e.functor.obj (𝟙_ C)
-- CategoryTheory.Monoidal.transportStruct_tensorHom
@[simps]
def transportStruct (e : C ≌ D) : MonoidalCategoryStruct.{v₂} D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: ∀ {X₁ Y₁ X₂ Y₂ : D} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂), f ⊗ g = e.functor.map (e.inverse.map f ⊗ e.inverse.map g)
-- CategoryTheory.Monoidal.transportStruct_tensorObj
@[simps]
def transportStruct (e : C ≌ D) : MonoidalCategoryStruct.{v₂} D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D) (X Y : D)
Goal: X ⊗ Y = e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)
-- CategoryTheory.Monoidal.transportStruct_whiskerRight
@[simps]
def transportStruct (e : C ≌ D) : MonoidalCategoryStruct.{v₂} D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: ∀ {X₁ X₂ : D} (f : X₁ ⟶ X₂) (X : D), f ▷ X = e.functor.map (e.inverse.map f ▷ e.inverse.obj X)
-- CategoryTheory.Monoidal.transportStruct_associator
@[simps]
def transportStruct (e : C ≌ D) : MonoidalCategoryStruct.{v₂} D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D) (X Y Z : D)
Goal: α_ X Y Z =
  e.functor.mapIso
    (((e.unitIso.app (e.inverse.obj X ⊗ e.inverse.obj Y)).symm ⊗ CategoryTheory.Iso.refl (e.inverse.obj Z)) ≪≫
      α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z) ≪≫
        (CategoryTheory.Iso.refl (e.inverse.obj X) ⊗ e.unitIso.app (e.inverse.obj Y ⊗ e.inverse.obj Z)))
-- CategoryTheory.Monoidal.fromTransported_toLaxMonoidalFunctor_ε
@[simps!]
def fromTransported (e : C ≌ D) : MonoidalFunctor (Transported e) C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: (CategoryTheory.Monoidal.fromTransported e).ε = e.unitIso.hom.app (𝟙_ C)
-- CategoryTheory.Monoidal.fromTransported_toLaxMonoidalFunctor_toFunctor
@[simps!]
def fromTransported (e : C ≌ D) : MonoidalFunctor (Transported e) C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: (CategoryTheory.Monoidal.fromTransported e).toFunctor = e.inverse
-- CategoryTheory.Monoidal.fromTransported_toLaxMonoidalFunctor_μ
@[simps!]
def fromTransported (e : C ≌ D) : MonoidalFunctor (Transported e) C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D) (X Y : CategoryTheory.Monoidal.Transported e)
Goal: (CategoryTheory.Monoidal.fromTransported e).μ X Y = e.unitIso.hom.app (e.inverse.obj X ⊗ e.inverse.obj Y)
-- CategoryTheory.Monoidal.toTransported_toLaxMonoidalFunctor_toFunctor
@[simps!]
def toTransported (e : C ≌ D) : MonoidalFunctor C (Transported e) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: (CategoryTheory.Monoidal.toTransported e).toFunctor = e.functor
-- CategoryTheory.Monoidal.toTransported_toLaxMonoidalFunctor_ε
@[simps!]
def toTransported (e : C ≌ D) : MonoidalFunctor C (Transported e) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: (CategoryTheory.Monoidal.toTransported e).ε =
  e.symm.unit.app (e.functor.obj (𝟙_ C)) ≫ CategoryTheory.inv (e.functor.map (e.unitIso.hom.app (𝟙_ C)))
-- CategoryTheory.Monoidal.toTransported_toLaxMonoidalFunctor_μ
@[simps!]
def toTransported (e : C ≌ D) : MonoidalFunctor C (Transported e) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D) (X Y : C)
Goal: (CategoryTheory.Monoidal.toTransported e).μ X Y =
  e.symm.unit.app (e.functor.obj (e.inverse.obj (e.functor.obj X) ⊗ e.inverse.obj (e.functor.obj Y))) ≫
    CategoryTheory.inv
        (e.functor.map (e.unitIso.hom.app (e.inverse.obj (e.functor.obj X) ⊗ e.inverse.obj (e.functor.obj Y)))) ≫
      e.functor.map (e.symm.counit.app X ⊗ e.symm.counit.app Y)
-- CategoryTheory.Monoidal.transportedMonoidalUnitIso_inv
@[simps! hom inv]
def transportedMonoidalUnitIso (e : C ≌ D) :
    LaxMonoidalFunctor.id C ≅
      (toTransported e).toLaxMonoidalFunctor ⊗⋙ (fromTransported e).toLaxMonoidalFunctor 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: (CategoryTheory.Monoidal.transportedMonoidalUnitIso e).inv =
  CategoryTheory.monoidalCounit (CategoryTheory.Monoidal.fromTransported e) e.symm.toAdjunction
-- CategoryTheory.Monoidal.transportedMonoidalUnitIso_hom
@[simps! hom inv]
def transportedMonoidalUnitIso (e : C ≌ D) :
    LaxMonoidalFunctor.id C ≅
      (toTransported e).toLaxMonoidalFunctor ⊗⋙ (fromTransported e).toLaxMonoidalFunctor 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: (CategoryTheory.Monoidal.transportedMonoidalUnitIso e).hom =
  CategoryTheory.inv (CategoryTheory.monoidalCounit (CategoryTheory.Monoidal.fromTransported e) e.symm.toAdjunction)
-- CategoryTheory.Monoidal.transportedMonoidalCounitIso_inv
@[simps! hom inv]
def transportedMonoidalCounitIso (e : C ≌ D) :
    (fromTransported e).toLaxMonoidalFunctor ⊗⋙ (toTransported e).toLaxMonoidalFunctor ≅
      LaxMonoidalFunctor.id (Transported e) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: (CategoryTheory.Monoidal.transportedMonoidalCounitIso e).inv =
  CategoryTheory.monoidalUnit (CategoryTheory.Monoidal.fromTransported e) e.symm.toAdjunction