ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- MulOpposite.op_inj
@[to_additive (attr := simp)]
theorem op_inj {x y : α} : op x = op y ↔ x = y 
Arguments: {α : Type u_1} {x y : α}
Goal: MulOpposite.op x = MulOpposite.op y ↔ x = y
-- AddOpposite.unop_inj
@[to_additive (attr := simp, nolint simpComm)]
theorem unop_inj {x y : αᵐᵒᵖ} : unop x = unop y ↔ x = y 
Arguments: {α : Type u_1} {x y : αᵃᵒᵖ}
Goal: AddOpposite.unop x = AddOpposite.unop y ↔ x = y
-- MulOpposite.unop_inj
@[to_additive (attr := simp, nolint simpComm)]
theorem unop_inj {x y : αᵐᵒᵖ} : unop x = unop y ↔ x = y 
Arguments: {α : Type u_1} {x y : αᵐᵒᵖ}
Goal: MulOpposite.unop x = MulOpposite.unop y ↔ x = y
-- MulOpposite.op_zero
@[simp] lemma op_zero [Zero α] : op (0 : α) = 0 
Arguments: {α : Type u_1} [Zero α]
Goal: MulOpposite.op 0 = 0
-- MulOpposite.unop_zero
@[simp] lemma unop_zero [Zero α] : unop (0 : αᵐᵒᵖ) = 0 
Arguments: {α : Type u_1} [Zero α]
Goal: MulOpposite.unop 0 = 0
-- AddOpposite.op_zero
@[to_additive (attr := simp)] lemma op_one [One α] : op (1 : α) = 1 
Arguments: {α : Type u_1} [Zero α]
Goal: AddOpposite.op 0 = 0
-- MulOpposite.op_one
@[to_additive (attr := simp)] lemma op_one [One α] : op (1 : α) = 1 
Arguments: {α : Type u_1} [One α]
Goal: MulOpposite.op 1 = 1
-- AddOpposite.unop_zero
@[to_additive (attr := simp)] lemma unop_one [One α] : unop (1 : αᵐᵒᵖ) = 1 
Arguments: {α : Type u_1} [Zero α]
Goal: AddOpposite.unop 0 = 0
-- MulOpposite.unop_one
@[to_additive (attr := simp)] lemma unop_one [One α] : unop (1 : αᵐᵒᵖ) = 1 
Arguments: {α : Type u_1} [One α]
Goal: MulOpposite.unop 1 = 1
-- MulOpposite.op_add
@[simp] lemma op_add [Add α] (x y : α) : op (x + y) = op x + op y 
Arguments: {α : Type u_1} [Add α] (x y : α)
Goal: MulOpposite.op (x + y) = MulOpposite.op x + MulOpposite.op y
-- MulOpposite.unop_add
@[simp] lemma unop_add [Add α] (x y : αᵐᵒᵖ) : unop (x + y) = unop x + unop y 
Arguments: {α : Type u_1} [Add α] (x y : αᵐᵒᵖ)
Goal: MulOpposite.unop (x + y) = MulOpposite.unop x + MulOpposite.unop y
-- MulOpposite.op_neg
@[simp] lemma op_neg [Neg α] (x : α) : op (-x) = -op x 
Arguments: {α : Type u_1} [Neg α] (x : α)
Goal: MulOpposite.op (-x) = -MulOpposite.op x
-- MulOpposite.unop_neg
@[simp] lemma unop_neg [Neg α] (x : αᵐᵒᵖ) : unop (-x) = -unop x 
Arguments: {α : Type u_1} [Neg α] (x : αᵐᵒᵖ)
Goal: MulOpposite.unop (-x) = -MulOpposite.unop x
-- AddOpposite.op_add
@[to_additive (attr := simp)] lemma op_mul [Mul α] (x y : α) : op (x * y) = op y * op x 
Arguments: {α : Type u_1} [Add α] (x y : α)
Goal: AddOpposite.op (x + y) = AddOpposite.op y + AddOpposite.op x
-- MulOpposite.op_mul
@[to_additive (attr := simp)] lemma op_mul [Mul α] (x y : α) : op (x * y) = op y * op x 
Arguments: {α : Type u_1} [Mul α] (x y : α)
Goal: MulOpposite.op (x * y) = MulOpposite.op y * MulOpposite.op x
-- MulOpposite.unop_mul
@[to_additive (attr := simp)]
lemma unop_mul [Mul α] (x y : αᵐᵒᵖ) : unop (x * y) = unop y * unop x 
Arguments: {α : Type u_1} [Mul α] (x y : αᵐᵒᵖ)
Goal: MulOpposite.unop (x * y) = MulOpposite.unop y * MulOpposite.unop x
-- AddOpposite.unop_add
@[to_additive (attr := simp)]
lemma unop_mul [Mul α] (x y : αᵐᵒᵖ) : unop (x * y) = unop y * unop x 
Arguments: {α : Type u_1} [Add α] (x y : αᵃᵒᵖ)
Goal: AddOpposite.unop (x + y) = AddOpposite.unop y + AddOpposite.unop x
-- AddOpposite.op_neg
@[to_additive (attr := simp)] lemma op_inv [Inv α] (x : α) : op x⁻¹ = (op x)⁻¹ 
Arguments: {α : Type u_1} [Neg α] (x : α)
Goal: AddOpposite.op (-x) = -AddOpposite.op x
-- MulOpposite.op_inv
@[to_additive (attr := simp)] lemma op_inv [Inv α] (x : α) : op x⁻¹ = (op x)⁻¹ 
Arguments: {α : Type u_1} [Inv α] (x : α)
Goal: MulOpposite.op x⁻¹ = (MulOpposite.op x)⁻¹
-- MulOpposite.unop_inv
@[to_additive (attr := simp)] lemma unop_inv [Inv α] (x : αᵐᵒᵖ) : unop x⁻¹ = (unop x)⁻¹ 
Arguments: {α : Type u_1} [Inv α] (x : αᵐᵒᵖ)
Goal: MulOpposite.unop x⁻¹ = (MulOpposite.unop x)⁻¹
-- AddOpposite.unop_neg
@[to_additive (attr := simp)] lemma unop_inv [Inv α] (x : αᵐᵒᵖ) : unop x⁻¹ = (unop x)⁻¹ 
Arguments: {α : Type u_1} [Neg α] (x : αᵃᵒᵖ)
Goal: AddOpposite.unop (-x) = -AddOpposite.unop x
-- MulOpposite.op_sub
@[simp] lemma op_sub [Sub α] (x y : α) : op (x - y) = op x - op y 
Arguments: {α : Type u_1} [Sub α] (x y : α)
Goal: MulOpposite.op (x - y) = MulOpposite.op x - MulOpposite.op y
-- MulOpposite.unop_sub
@[simp] lemma unop_sub [Sub α] (x y : αᵐᵒᵖ) : unop (x - y) = unop x - unop y 
Arguments: {α : Type u_1} [Sub α] (x y : αᵐᵒᵖ)
Goal: MulOpposite.unop (x - y) = MulOpposite.unop x - MulOpposite.unop y
-- MulOpposite.op_smul
@[to_additive (attr := simp)]
lemma op_smul [SMul α β] (a : α) (b : β) : op (a • b) = a • op b 
Arguments: {α : Type u_1} {β : Type u_2} [SMul α β] (a : α) (b : β)
Goal: MulOpposite.op (a • b) = a • MulOpposite.op b
-- AddOpposite.op_vadd
@[to_additive (attr := simp)]
lemma op_smul [SMul α β] (a : α) (b : β) : op (a • b) = a • op b 
Arguments: {α : Type u_1} {β : Type u_2} [VAdd α β] (a : α) (b : β)
Goal: AddOpposite.op (a +ᵥ b) = a +ᵥ AddOpposite.op b
-- AddOpposite.unop_vadd
@[to_additive (attr := simp)]
lemma unop_smul [SMul α β] (a : α) (b : βᵐᵒᵖ) : unop (a • b) = a • unop b 
Arguments: {α : Type u_1} {β : Type u_2} [VAdd α β] (a : α) (b : βᵃᵒᵖ)
Goal: AddOpposite.unop (a +ᵥ b) = a +ᵥ AddOpposite.unop b
-- MulOpposite.unop_smul
@[to_additive (attr := simp)]
lemma unop_smul [SMul α β] (a : α) (b : βᵐᵒᵖ) : unop (a • b) = a • unop b 
Arguments: {α : Type u_1} {β : Type u_2} [SMul α β] (a : α) (b : βᵐᵒᵖ)
Goal: MulOpposite.unop (a • b) = a • MulOpposite.unop b
-- MulOpposite.unop_eq_zero_iff
@[simp, nolint simpComm]
theorem unop_eq_zero_iff [Zero α] (a : αᵐᵒᵖ) : a.unop = (0 : α) ↔ a = (0 : αᵐᵒᵖ) 
Arguments: {α : Type u_1} [Zero α] (a : αᵐᵒᵖ)
Goal: MulOpposite.unop a = 0 ↔ a = 0
-- MulOpposite.op_eq_zero_iff
@[simp]
theorem op_eq_zero_iff [Zero α] (a : α) : op a = (0 : αᵐᵒᵖ) ↔ a = (0 : α) 
Arguments: {α : Type u_1} [Zero α] (a : α)
Goal: MulOpposite.op a = 0 ↔ a = 0
-- MulOpposite.unop_ne_zero_iff
theorem unop_ne_zero_iff [Zero α] (a : αᵐᵒᵖ) : a.unop ≠ (0 : α) ↔ a ≠ (0 : αᵐᵒᵖ) 
Arguments: {α : Type u_1} [Zero α] (a : αᵐᵒᵖ)
Goal: MulOpposite.unop a ≠ 0 ↔ a ≠ 0
-- MulOpposite.op_ne_zero_iff
theorem op_ne_zero_iff [Zero α] (a : α) : op a ≠ (0 : αᵐᵒᵖ) ↔ a ≠ (0 : α) 
Arguments: {α : Type u_1} [Zero α] (a : α)
Goal: MulOpposite.op a ≠ 0 ↔ a ≠ 0
-- AddOpposite.unop_eq_zero_iff
@[to_additive (attr := simp, nolint simpComm)]
theorem unop_eq_one_iff [One α] (a : αᵐᵒᵖ) : a.unop = 1 ↔ a = 1 
Arguments: {α : Type u_1} [Zero α] (a : αᵃᵒᵖ)
Goal: AddOpposite.unop a = 0 ↔ a = 0
-- MulOpposite.unop_eq_one_iff
@[to_additive (attr := simp, nolint simpComm)]
theorem unop_eq_one_iff [One α] (a : αᵐᵒᵖ) : a.unop = 1 ↔ a = 1 
Arguments: {α : Type u_1} [One α] (a : αᵐᵒᵖ)
Goal: MulOpposite.unop a = 1 ↔ a = 1
-- AddOpposite.op_eq_zero_iff
@[to_additive (attr := simp)]
lemma op_eq_one_iff [One α] (a : α) : op a = 1 ↔ a = 1 
Arguments: {α : Type u_1} [Zero α] (a : α)
Goal: AddOpposite.op a = 0 ↔ a = 0
-- MulOpposite.op_eq_one_iff
@[to_additive (attr := simp)]
lemma op_eq_one_iff [One α] (a : α) : op a = 1 ↔ a = 1 
Arguments: {α : Type u_1} [One α] (a : α)
Goal: MulOpposite.op a = 1 ↔ a = 1
-- AddOpposite.op_one
@[simp] lemma op_one [One α] : op (1 : α) = 1 
Arguments: {α : Type u_1} [One α]
Goal: AddOpposite.op 1 = 1
-- AddOpposite.unop_one
@[simp] lemma unop_one [One α] : unop 1 = (1 : α) 
Arguments: {α : Type u_1} [One α]
Goal: AddOpposite.unop 1 = 1
-- AddOpposite.op_eq_one_iff
@[simp] lemma op_eq_one_iff [One α] {a : α} : op a = 1 ↔ a = 1 
Arguments: {α : Type u_1} [One α] {a : α}
Goal: AddOpposite.op a = 1 ↔ a = 1
-- AddOpposite.unop_eq_one_iff
@[simp] lemma unop_eq_one_iff [One α] {a : αᵃᵒᵖ} : unop a = 1 ↔ a = 1 
Arguments: {α : Type u_1} [One α] {a : αᵃᵒᵖ}
Goal: AddOpposite.unop a = 1 ↔ a = 1
-- AddOpposite.op_mul
@[simp] lemma op_mul [Mul α] (a b : α) : op (a * b) = op a * op b 
Arguments: {α : Type u_1} [Mul α] (a b : α)
Goal: AddOpposite.op (a * b) = AddOpposite.op a * AddOpposite.op b
-- AddOpposite.unop_mul
@[simp] lemma unop_mul [Mul α] (a b : αᵃᵒᵖ) : unop (a * b) = unop a * unop b 
Arguments: {α : Type u_1} [Mul α] (a b : αᵃᵒᵖ)
Goal: AddOpposite.unop (a * b) = AddOpposite.unop a * AddOpposite.unop b
-- AddOpposite.op_inv
@[simp] lemma op_inv [Inv α] (a : α) : op a⁻¹ = (op a)⁻¹ 
Arguments: {α : Type u_1} [Inv α] (a : α)
Goal: AddOpposite.op a⁻¹ = (AddOpposite.op a)⁻¹
-- AddOpposite.unop_inv
@[simp] lemma unop_inv [Inv α] (a : αᵃᵒᵖ) : unop a⁻¹ = (unop a)⁻¹ 
Arguments: {α : Type u_1} [Inv α] (a : αᵃᵒᵖ)
Goal: AddOpposite.unop a⁻¹ = (AddOpposite.unop a)⁻¹
-- AddOpposite.op_div
@[simp] lemma op_div [Div α] (a b : α) : op (a / b) = op a / op b 
Arguments: {α : Type u_1} [Div α] (a b : α)
Goal: AddOpposite.op (a / b) = AddOpposite.op a / AddOpposite.op b
-- AddOpposite.unop_div
@[simp] lemma unop_div [Div α] (a b : αᵃᵒᵖ) : unop (a / b) = unop a / unop b 
Arguments: {α : Type u_1} [Div α] (a b : αᵃᵒᵖ)
Goal: AddOpposite.unop (a / b) = AddOpposite.unop a / AddOpposite.unop b
-- CategoryTheory.FreeBicategory.mk_vcomp
@[simp]
theorem mk_vcomp {f g h : a ⟶ b} (η : Hom₂ f g) (θ : Hom₂ g h) :
    (η.vcomp θ).mk = (η.mk ≫ θ.mk : f ⟶ h) 
Arguments: {B : Type u} [Quiver B] {a b : CategoryTheory.FreeBicategory B} {f g h : a ⟶ b} (η : CategoryTheory.FreeBicategory.Hom₂ f g) (θ : CategoryTheory.FreeBicategory.Hom₂ g h)
Goal: (η.vcomp θ).mk = CategoryTheory.CategoryStruct.comp η.mk θ.mk
-- CategoryTheory.FreeBicategory.mk_whisker_left
@[simp]
theorem mk_whisker_left (f : a ⟶ b) {g h : b ⟶ c} (η : Hom₂ g h) :
    (Hom₂.whisker_left f η).mk = (f ◁ η.mk : f ≫ g ⟶ f ≫ h) 
Arguments: {B : Type u} [Quiver B] {a b c : CategoryTheory.FreeBicategory B} (f : a ⟶ b) {g h : b ⟶ c} (η : CategoryTheory.FreeBicategory.Hom₂ g h)
Goal: (CategoryTheory.FreeBicategory.Hom₂.whisker_left f η).mk = CategoryTheory.Bicategory.whiskerLeft f η.mk
-- CategoryTheory.FreeBicategory.mk_whisker_right
@[simp]
theorem mk_whisker_right {f g : a ⟶ b} (η : Hom₂ f g) (h : b ⟶ c) :
    (Hom₂.whisker_right h η).mk = (η.mk ▷ h : f ≫ h ⟶ g ≫ h) 
Arguments: {B : Type u} [Quiver B] {a b c : CategoryTheory.FreeBicategory B} {f g : a ⟶ b} (η : CategoryTheory.FreeBicategory.Hom₂ f g) (h : b ⟶ c)
Goal: (CategoryTheory.FreeBicategory.Hom₂.whisker_right h η).mk = CategoryTheory.Bicategory.whiskerRight η.mk h
-- CategoryTheory.FreeBicategory.comp_def
theorem comp_def : Hom.comp f g = f ≫ g 
Arguments: {B : Type u} [Quiver B] {a b c : CategoryTheory.FreeBicategory B} (f : a ⟶ b) (g : b ⟶ c)
Goal: CategoryTheory.FreeBicategory.Hom.comp f g = CategoryTheory.CategoryStruct.comp f g
-- CategoryTheory.FreeBicategory.mk_id
@[simp]
theorem mk_id : Quot.mk _ (Hom₂.id f) = 𝟙 f 
Arguments: {B : Type u} [Quiver B] {a b : CategoryTheory.FreeBicategory B} (f : a ⟶ b)
Goal: Quot.mk CategoryTheory.FreeBicategory.Rel (CategoryTheory.FreeBicategory.Hom₂.id f) = CategoryTheory.CategoryStruct.id f
-- CategoryTheory.FreeBicategory.mk_associator_hom
@[simp]
theorem mk_associator_hom : Quot.mk _ (Hom₂.associator f g h) = (α_ f g h).hom 
Arguments: {B : Type u} [Quiver B] {a b c d : CategoryTheory.FreeBicategory B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d)
Goal: Quot.mk CategoryTheory.FreeBicategory.Rel (CategoryTheory.FreeBicategory.Hom₂.associator f g h) =
  (CategoryTheory.Bicategory.associator f g h).hom
-- CategoryTheory.FreeBicategory.mk_associator_inv
@[simp]
theorem mk_associator_inv : Quot.mk _ (Hom₂.associator_inv f g h) = (α_ f g h).inv 
Arguments: {B : Type u} [Quiver B] {a b c d : CategoryTheory.FreeBicategory B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d)
Goal: Quot.mk CategoryTheory.FreeBicategory.Rel (CategoryTheory.FreeBicategory.Hom₂.associator_inv f g h) =
  (CategoryTheory.Bicategory.associator f g h).inv
-- CategoryTheory.FreeBicategory.mk_left_unitor_hom
@[simp]
theorem mk_left_unitor_hom : Quot.mk _ (Hom₂.left_unitor f) = (λ_ f).hom 
Arguments: {B : Type u} [Quiver B] {a b : CategoryTheory.FreeBicategory B} (f : a ⟶ b)
Goal: Quot.mk CategoryTheory.FreeBicategory.Rel (CategoryTheory.FreeBicategory.Hom₂.left_unitor f) =
  (CategoryTheory.Bicategory.leftUnitor f).hom
-- CategoryTheory.FreeBicategory.mk_left_unitor_inv
@[simp]
theorem mk_left_unitor_inv : Quot.mk _ (Hom₂.left_unitor_inv f) = (λ_ f).inv 
Arguments: {B : Type u} [Quiver B] {a b : CategoryTheory.FreeBicategory B} (f : a ⟶ b)
Goal: Quot.mk CategoryTheory.FreeBicategory.Rel (CategoryTheory.FreeBicategory.Hom₂.left_unitor_inv f) =
  (CategoryTheory.Bicategory.leftUnitor f).inv
-- CategoryTheory.FreeBicategory.mk_right_unitor_hom
@[simp]
theorem mk_right_unitor_hom : Quot.mk _ (Hom₂.right_unitor f) = (ρ_ f).hom 
Arguments: {B : Type u} [Quiver B] {a b : CategoryTheory.FreeBicategory B} (f : a ⟶ b)
Goal: Quot.mk CategoryTheory.FreeBicategory.Rel (CategoryTheory.FreeBicategory.Hom₂.right_unitor f) =
  (CategoryTheory.Bicategory.rightUnitor f).hom
-- CategoryTheory.FreeBicategory.mk_right_unitor_inv
@[simp]
theorem mk_right_unitor_inv : Quot.mk _ (Hom₂.right_unitor_inv f) = (ρ_ f).inv 
Arguments: {B : Type u} [Quiver B] {a b : CategoryTheory.FreeBicategory B} (f : a ⟶ b)
Goal: Quot.mk CategoryTheory.FreeBicategory.Rel (CategoryTheory.FreeBicategory.Hom₂.right_unitor_inv f) =
  (CategoryTheory.Bicategory.rightUnitor f).inv
-- CategoryTheory.FreeBicategory.of_map
@[simps]
def of : Prefunctor B (FreeBicategory B) 
Arguments: {B : Type u} [Quiver B]
Goal: ∀ (x x_1 : B) (f : x ⟶ x_1), CategoryTheory.FreeBicategory.of.map f = CategoryTheory.FreeBicategory.Hom.of f
-- CategoryTheory.FreeBicategory.of_obj
@[simps]
def of : Prefunctor B (FreeBicategory B) 
Arguments: {B : Type u} [Quiver B] (a : B)
Goal: CategoryTheory.FreeBicategory.of.obj a = id a
-- CategoryTheory.FreeBicategory.liftHom_id
@[simp]
theorem liftHom_id (a : FreeBicategory B) : liftHom F (𝟙 a) = 𝟙 (F.obj a) 
Arguments: {B : Type u₁} [Quiver B] {C : Type u₂} [CategoryTheory.CategoryStruct.{v₂, u₂} C] (F : B ⥤q C) (a : CategoryTheory.FreeBicategory B)
Goal: CategoryTheory.FreeBicategory.liftHom F (CategoryTheory.CategoryStruct.id a) =
  CategoryTheory.CategoryStruct.id (F.obj a)
-- CategoryTheory.FreeBicategory.liftHom_comp
@[simp]
theorem liftHom_comp {a b c : FreeBicategory B} (f : a ⟶ b) (g : b ⟶ c) :
    liftHom F (f ≫ g) = liftHom F f ≫ liftHom F g 
Arguments: {B : Type u₁} [Quiver B] {C : Type u₂} [CategoryTheory.CategoryStruct.{v₂, u₂} C] (F : B ⥤q C) {a b c : CategoryTheory.FreeBicategory B} (f : a ⟶ b) (g : b ⟶ c)
Goal: CategoryTheory.FreeBicategory.liftHom F (CategoryTheory.CategoryStruct.comp f g) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.FreeBicategory.liftHom F f)
    (CategoryTheory.FreeBicategory.liftHom F g)
-- CategoryTheory.FreeBicategory.liftHom₂_congr
theorem liftHom₂_congr {a b : FreeBicategory B} {f g : a ⟶ b} {η θ : Hom₂ f g} (H : Rel η θ) :
    liftHom₂ F η = liftHom₂ F θ 
Arguments: {B : Type u₁} [Quiver B] {C : Type u₂} [CategoryTheory.Bicategory C] (F : B ⥤q C) {a b : CategoryTheory.FreeBicategory B} {f g : a ⟶ b} {η θ : CategoryTheory.FreeBicategory.Hom₂ f g} (H : CategoryTheory.FreeBicategory.Rel η θ)
Goal: CategoryTheory.FreeBicategory.liftHom₂ F η = CategoryTheory.FreeBicategory.liftHom₂ F θ
-- CategoryTheory.FreeBicategory.lift_mapComp
@[simps]
def lift : Pseudofunctor (FreeBicategory B) C 
Arguments: {B : Type u₁} [Quiver B] {C : Type u₂} [CategoryTheory.Bicategory C] (F : B ⥤q C)
Goal: ∀ {a b c : CategoryTheory.FreeBicategory B} (f : a ⟶ b) (g : b ⟶ c),
  (CategoryTheory.FreeBicategory.lift F).mapComp f g =
    CategoryTheory.Iso.refl
      ({ obj := F.obj, map := fun {X Y} => CategoryTheory.FreeBicategory.liftHom F,
            map₂ := fun {a b} {f g} => Quot.lift (CategoryTheory.FreeBicategory.liftHom₂ F) ⋯, map₂_id := ⋯,
            map₂_comp := ⋯ }.map
        (CategoryTheory.CategoryStruct.comp f g))
-- CategoryTheory.FreeBicategory.lift_toPrelaxFunctor_toPrelaxFunctorStruct_map₂
@[simps]
def lift : Pseudofunctor (FreeBicategory B) C 
Arguments: {B : Type u₁} [Quiver B] {C : Type u₂} [CategoryTheory.Bicategory C] (F : B ⥤q C)
Goal: ∀ {a b : CategoryTheory.FreeBicategory B} {f g : a ⟶ b} (a_1 : Quot CategoryTheory.FreeBicategory.Rel),
  (CategoryTheory.FreeBicategory.lift F).map₂ a_1 = Quot.lift (CategoryTheory.FreeBicategory.liftHom₂ F) ⋯ a_1
-- CategoryTheory.FreeBicategory.lift_mapId
@[simps]
def lift : Pseudofunctor (FreeBicategory B) C 
Arguments: {B : Type u₁} [Quiver B] {C : Type u₂} [CategoryTheory.Bicategory C] (F : B ⥤q C) (a : CategoryTheory.FreeBicategory B)
Goal: (CategoryTheory.FreeBicategory.lift F).mapId a =
  CategoryTheory.Iso.refl
    ({ obj := F.obj, map := fun {X Y} => CategoryTheory.FreeBicategory.liftHom F,
          map₂ := fun {a b} {f g} => Quot.lift (CategoryTheory.FreeBicategory.liftHom₂ F) ⋯, map₂_id := ⋯,
          map₂_comp := ⋯ }.map
      (CategoryTheory.CategoryStruct.id a))
-- CategoryTheory.FreeBicategory.lift_toPrelaxFunctor_toPrelaxFunctorStruct_toPrefunctor_obj
@[simps]
def lift : Pseudofunctor (FreeBicategory B) C 
Arguments: {B : Type u₁} [Quiver B] {C : Type u₂} [CategoryTheory.Bicategory C] (F : B ⥤q C)
Goal: ∀ (a : B), (CategoryTheory.FreeBicategory.lift F).obj a = F.obj a
-- CategoryTheory.FreeBicategory.lift_toPrelaxFunctor_toPrelaxFunctorStruct_toPrefunctor_map
@[simps]
def lift : Pseudofunctor (FreeBicategory B) C 
Arguments: {B : Type u₁} [Quiver B] {C : Type u₂} [CategoryTheory.Bicategory C] (F : B ⥤q C)
Goal: ∀ {X Y : CategoryTheory.FreeBicategory B} (a : X ⟶ Y),
  (CategoryTheory.FreeBicategory.lift F).map a = CategoryTheory.FreeBicategory.liftHom F a
-- CategoryTheory.Pseudofunctor.map₂_right_unitor
structure Pseudofunctor (B : Type u₁) [Bicategory.{w₁, v₁} B] (C : Type u₂)
    [Bicategory.{w₂, v₂} C] extends PrelaxFunctor B C where
  mapId (a : B) : map (𝟙 a) ≅ 𝟙 (obj a)
  mapComp {a b c : B} (f : a ⟶ b) (g : b ⟶ c) : map (f ≫ g) ≅ map f ≫ map g
  map₂_whisker_left :
    ∀ {a b c : B} (f : a ⟶ b) {g h : b ⟶ c} (η : g ⟶ h),
      map₂ (f ◁ η) = (mapComp f g).hom ≫ map f ◁ map₂ η ≫ (mapComp f h).inv := by
    aesop_cat
  map₂_whisker_right :
    ∀ {a b c : B} {f g : a ⟶ b} (η : f ⟶ g) (h : b ⟶ c),
      map₂ (η ▷ h) = (mapComp f h).hom ≫ map₂ η ▷ map h ≫ (mapComp g h).inv := by
    aesop_cat
  map₂_associator :
    ∀ {a b c d : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d),
      map₂ (α_ f g h).hom = (mapComp (f ≫ g) h).hom ≫ (mapComp f g).hom ▷ map h ≫
      (α_ (map f) (map g) (map h)).hom ≫ map f ◁ (mapComp g h).inv ≫
      (mapComp f (g ≫ h)).inv := by
    aesop_cat
  map₂_left_unitor :
    ∀ {a b : B} (f : a ⟶ b),
      map₂ (λ_ f).hom = (mapComp (𝟙 a) f).hom ≫ (mapId a).hom ▷ map f ≫ (λ_ (map f)).hom := by
    aesop_cat
  map₂_right_unitor :
    ∀ {a b : B} (f : a ⟶ b),
      map₂ (ρ_ f).hom = (mapComp f (𝟙 b)).hom ≫ map f ◁ (mapId b).hom ≫ (ρ_ (map f)).hom := by
    aesop_cat
Arguments: {B : Type u₁} [CategoryTheory.Bicategory B] {C : Type u₂} [CategoryTheory.Bicategory C] (self : CategoryTheory.Pseudofunctor B C) {a b : B} (f : a ⟶ b)
Goal: self.map₂ (CategoryTheory.Bicategory.rightUnitor f).hom =
  CategoryTheory.CategoryStruct.comp (self.mapComp f (CategoryTheory.CategoryStruct.id b)).hom
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (self.map f) (self.mapId b).hom)
      (CategoryTheory.Bicategory.rightUnitor (self.map f)).hom)
-- CategoryTheory.Pseudofunctor.map₂_whisker_right
structure Pseudofunctor (B : Type u₁) [Bicategory.{w₁, v₁} B] (C : Type u₂)
    [Bicategory.{w₂, v₂} C] extends PrelaxFunctor B C where
  mapId (a : B) : map (𝟙 a) ≅ 𝟙 (obj a)
  mapComp {a b c : B} (f : a ⟶ b) (g : b ⟶ c) : map (f ≫ g) ≅ map f ≫ map g
  map₂_whisker_left :
    ∀ {a b c : B} (f : a ⟶ b) {g h : b ⟶ c} (η : g ⟶ h),
      map₂ (f ◁ η) = (mapComp f g).hom ≫ map f ◁ map₂ η ≫ (mapComp f h).inv := by
    aesop_cat
  map₂_whisker_right :
    ∀ {a b c : B} {f g : a ⟶ b} (η : f ⟶ g) (h : b ⟶ c),
      map₂ (η ▷ h) = (mapComp f h).hom ≫ map₂ η ▷ map h ≫ (mapComp g h).inv := by
    aesop_cat
  map₂_associator :
    ∀ {a b c d : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d),
      map₂ (α_ f g h).hom = (mapComp (f ≫ g) h).hom ≫ (mapComp f g).hom ▷ map h ≫
      (α_ (map f) (map g) (map h)).hom ≫ map f ◁ (mapComp g h).inv ≫
      (mapComp f (g ≫ h)).inv := by
    aesop_cat
  map₂_left_unitor :
    ∀ {a b : B} (f : a ⟶ b),
      map₂ (λ_ f).hom = (mapComp (𝟙 a) f).hom ≫ (mapId a).hom ▷ map f ≫ (λ_ (map f)).hom := by
    aesop_cat
  map₂_right_unitor :
    ∀ {a b : B} (f : a ⟶ b),
      map₂ (ρ_ f).hom = (mapComp f (𝟙 b)).hom ≫ map f ◁ (mapId b).hom ≫ (ρ_ (map f)).hom := by
    aesop_cat
Arguments: {B : Type u₁} [CategoryTheory.Bicategory B] {C : Type u₂} [CategoryTheory.Bicategory C] (self : CategoryTheory.Pseudofunctor B C) {a b c : B} {f g : a ⟶ b} (η : f ⟶ g) (h : b ⟶ c)
Goal: self.map₂ (CategoryTheory.Bicategory.whiskerRight η h) =
  CategoryTheory.CategoryStruct.comp (self.mapComp f h).hom
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight (self.map₂ η) (self.map h))
      (self.mapComp g h).inv)
-- CategoryTheory.Pseudofunctor.map₂_whisker_left
structure Pseudofunctor (B : Type u₁) [Bicategory.{w₁, v₁} B] (C : Type u₂)
    [Bicategory.{w₂, v₂} C] extends PrelaxFunctor B C where
  mapId (a : B) : map (𝟙 a) ≅ 𝟙 (obj a)
  mapComp {a b c : B} (f : a ⟶ b) (g : b ⟶ c) : map (f ≫ g) ≅ map f ≫ map g
  map₂_whisker_left :
    ∀ {a b c : B} (f : a ⟶ b) {g h : b ⟶ c} (η : g ⟶ h),
      map₂ (f ◁ η) = (mapComp f g).hom ≫ map f ◁ map₂ η ≫ (mapComp f h).inv := by
    aesop_cat
  map₂_whisker_right :
    ∀ {a b c : B} {f g : a ⟶ b} (η : f ⟶ g) (h : b ⟶ c),
      map₂ (η ▷ h) = (mapComp f h).hom ≫ map₂ η ▷ map h ≫ (mapComp g h).inv := by
    aesop_cat
  map₂_associator :
    ∀ {a b c d : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d),
      map₂ (α_ f g h).hom = (mapComp (f ≫ g) h).hom ≫ (mapComp f g).hom ▷ map h ≫
      (α_ (map f) (map g) (map h)).hom ≫ map f ◁ (mapComp g h).inv ≫
      (mapComp f (g ≫ h)).inv := by
    aesop_cat
  map₂_left_unitor :
    ∀ {a b : B} (f : a ⟶ b),
      map₂ (λ_ f).hom = (mapComp (𝟙 a) f).hom ≫ (mapId a).hom ▷ map f ≫ (λ_ (map f)).hom := by
    aesop_cat
  map₂_right_unitor :
    ∀ {a b : B} (f : a ⟶ b),
      map₂ (ρ_ f).hom = (mapComp f (𝟙 b)).hom ≫ map f ◁ (mapId b).hom ≫ (ρ_ (map f)).hom := by
    aesop_cat
Arguments: {B : Type u₁} [CategoryTheory.Bicategory B] {C : Type u₂} [CategoryTheory.Bicategory C] (self : CategoryTheory.Pseudofunctor B C) {a b c : B} (f : a ⟶ b) {g h : b ⟶ c} (η : g ⟶ h)
Goal: self.map₂ (CategoryTheory.Bicategory.whiskerLeft f η) =
  CategoryTheory.CategoryStruct.comp (self.mapComp f g).hom
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (self.map f) (self.map₂ η))
      (self.mapComp f h).inv)
-- CategoryTheory.Pseudofunctor.map₂_left_unitor
structure Pseudofunctor (B : Type u₁) [Bicategory.{w₁, v₁} B] (C : Type u₂)
    [Bicategory.{w₂, v₂} C] extends PrelaxFunctor B C where
  mapId (a : B) : map (𝟙 a) ≅ 𝟙 (obj a)
  mapComp {a b c : B} (f : a ⟶ b) (g : b ⟶ c) : map (f ≫ g) ≅ map f ≫ map g
  map₂_whisker_left :
    ∀ {a b c : B} (f : a ⟶ b) {g h : b ⟶ c} (η : g ⟶ h),
      map₂ (f ◁ η) = (mapComp f g).hom ≫ map f ◁ map₂ η ≫ (mapComp f h).inv := by
    aesop_cat
  map₂_whisker_right :
    ∀ {a b c : B} {f g : a ⟶ b} (η : f ⟶ g) (h : b ⟶ c),
      map₂ (η ▷ h) = (mapComp f h).hom ≫ map₂ η ▷ map h ≫ (mapComp g h).inv := by
    aesop_cat
  map₂_associator :
    ∀ {a b c d : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d),
      map₂ (α_ f g h).hom = (mapComp (f ≫ g) h).hom ≫ (mapComp f g).hom ▷ map h ≫
      (α_ (map f) (map g) (map h)).hom ≫ map f ◁ (mapComp g h).inv ≫
      (mapComp f (g ≫ h)).inv := by
    aesop_cat
  map₂_left_unitor :
    ∀ {a b : B} (f : a ⟶ b),
      map₂ (λ_ f).hom = (mapComp (𝟙 a) f).hom ≫ (mapId a).hom ▷ map f ≫ (λ_ (map f)).hom := by
    aesop_cat
  map₂_right_unitor :
    ∀ {a b : B} (f : a ⟶ b),
      map₂ (ρ_ f).hom = (mapComp f (𝟙 b)).hom ≫ map f ◁ (mapId b).hom ≫ (ρ_ (map f)).hom := by
    aesop_cat
Arguments: {B : Type u₁} [CategoryTheory.Bicategory B] {C : Type u₂} [CategoryTheory.Bicategory C] (self : CategoryTheory.Pseudofunctor B C) {a b : B} (f : a ⟶ b)
Goal: self.map₂ (CategoryTheory.Bicategory.leftUnitor f).hom =
  CategoryTheory.CategoryStruct.comp (self.mapComp (CategoryTheory.CategoryStruct.id a) f).hom
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight (self.mapId a).hom (self.map f))
      (CategoryTheory.Bicategory.leftUnitor (self.map f)).hom)