l3lab/ntp-mathlib huggingface dataset:
theorem liftHom₂_congr {a b : FreeBicategory B} {f g : a ⟶ b} {η θ : Hom₂ f g} (H : Rel η θ) :
    liftHom₂ F η = liftHom₂ F θ := by induction H <;> (

Proof state:
case whisker_right_comp
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ c✝ d✝ : B
f✝ f'✝ : Hom a✝ b✝
g✝ : Hom b✝ c✝
h✝ : Hom c✝ d✝
η✝ : Hom₂ f✝ f'✝
⊢ liftHom₂ F (Hom₂.whisker_right (Hom.comp g✝ h✝) η✝) =
    liftHom₂ F
      (Hom₂.vcomp (Hom₂.associator_inv f✝ g✝ h✝)
        (Hom₂.vcomp (Hom₂.whisker_right h✝ (Hom₂.whisker_right g✝ η✝)) (Hom₂.associator f'✝ g✝ h✝)))

Next tactic:
dsimp [liftHom₂]
theorem liftHom₂_congr {a b : FreeBicategory B} {f g : a ⟶ b} {η θ : Hom₂ f g} (H : Rel η θ) :
    liftHom₂ F η = liftHom₂ F θ := by induction H <;> (dsimp [liftHom₂]; 

Proof state:
case whisker_right_comp
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ c✝ d✝ : B
f✝ f'✝ : Hom a✝ b✝
g✝ : Hom b✝ c✝
h✝ : Hom c✝ d✝
η✝ : Hom₂ f✝ f'✝
⊢ liftHom₂ F η✝ ▷ (liftHom F g✝ ≫ liftHom F h✝) =
    (α_ (liftHom F f✝) (liftHom F g✝) (liftHom F h✝)).inv ≫
      liftHom₂ F η✝ ▷ liftHom F g✝ ▷ liftHom F h✝ ≫ (α_ (liftHom F f'✝) (liftHom F g✝) (liftHom F h✝)).hom

Next tactic:
aesop_cat
theorem liftHom₂_congr {a b : FreeBicategory B} {f g : a ⟶ b} {η θ : Hom₂ f g} (H : Rel η θ) :
    liftHom₂ F η = liftHom₂ F θ := by induction H <;> (

Proof state:
case whisker_assoc
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ c✝ d✝ : B
f✝ : Hom a✝ b✝
g✝ g'✝ : Hom b✝ c✝
η✝ : Hom₂ g✝ g'✝
h✝ : Hom c✝ d✝
⊢ liftHom₂ F (Hom₂.whisker_right h✝ (Hom₂.whisker_left f✝ η✝)) =
    liftHom₂ F
      (Hom₂.vcomp (Hom₂.associator f✝ g✝ h✝)
        (Hom₂.vcomp (Hom₂.whisker_left f✝ (Hom₂.whisker_right h✝ η✝)) (Hom₂.associator_inv f✝ g'✝ h✝)))

Next tactic:
dsimp [liftHom₂]
theorem liftHom₂_congr {a b : FreeBicategory B} {f g : a ⟶ b} {η θ : Hom₂ f g} (H : Rel η θ) :
    liftHom₂ F η = liftHom₂ F θ := by induction H <;> (dsimp [liftHom₂]; 

Proof state:
case whisker_assoc
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ c✝ d✝ : B
f✝ : Hom a✝ b✝
g✝ g'✝ : Hom b✝ c✝
η✝ : Hom₂ g✝ g'✝
h✝ : Hom c✝ d✝
⊢ (liftHom F f✝ ◁ liftHom₂ F η✝) ▷ liftHom F h✝ =
    (α_ (liftHom F f✝) (liftHom F g✝) (liftHom F h✝)).hom ≫
      liftHom F f✝ ◁ liftHom₂ F η✝ ▷ liftHom F h✝ ≫ (α_ (liftHom F f✝) (liftHom F g'✝) (liftHom F h✝)).inv

Next tactic:
aesop_cat
theorem liftHom₂_congr {a b : FreeBicategory B} {f g : a ⟶ b} {η θ : Hom₂ f g} (H : Rel η θ) :
    liftHom₂ F η = liftHom₂ F θ := by induction H <;> (

Proof state:
case whisker_exchange
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ c✝ : B
f✝ g✝ : Hom a✝ b✝
h✝ i✝ : Hom b✝ c✝
η✝ : Hom₂ f✝ g✝
θ✝ : Hom₂ h✝ i✝
⊢ liftHom₂ F (Hom₂.vcomp (Hom₂.whisker_left f✝ θ✝) (Hom₂.whisker_right i✝ η✝)) =
    liftHom₂ F (Hom₂.vcomp (Hom₂.whisker_right h✝ η✝) (Hom₂.whisker_left g✝ θ✝))

Next tactic:
dsimp [liftHom₂]
theorem liftHom₂_congr {a b : FreeBicategory B} {f g : a ⟶ b} {η θ : Hom₂ f g} (H : Rel η θ) :
    liftHom₂ F η = liftHom₂ F θ := by induction H <;> (dsimp [liftHom₂]; 

Proof state:
case whisker_exchange
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ c✝ : B
f✝ g✝ : Hom a✝ b✝
h✝ i✝ : Hom b✝ c✝
η✝ : Hom₂ f✝ g✝
θ✝ : Hom₂ h✝ i✝
⊢ liftHom F f✝ ◁ liftHom₂ F θ✝ ≫ liftHom₂ F η✝ ▷ liftHom F i✝ =
    liftHom₂ F η✝ ▷ liftHom F h✝ ≫ liftHom F g✝ ◁ liftHom₂ F θ✝

Next tactic:
aesop_cat
theorem liftHom₂_congr {a b : FreeBicategory B} {f g : a ⟶ b} {η θ : Hom₂ f g} (H : Rel η θ) :
    liftHom₂ F η = liftHom₂ F θ := by induction H <;> (

Proof state:
case associator_hom_inv
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ c✝ d✝ : B
f✝ : Hom a✝ b✝
g✝ : Hom b✝ c✝
h✝ : Hom c✝ d✝
⊢ liftHom₂ F (Hom₂.vcomp (Hom₂.associator f✝ g✝ h✝) (Hom₂.associator_inv f✝ g✝ h✝)) =
    liftHom₂ F (Hom₂.id (Hom.comp (Hom.comp f✝ g✝) h✝))

Next tactic:
dsimp [liftHom₂]
theorem liftHom₂_congr {a b : FreeBicategory B} {f g : a ⟶ b} {η θ : Hom₂ f g} (H : Rel η θ) :
    liftHom₂ F η = liftHom₂ F θ := by induction H <;> (dsimp [liftHom₂]; 

Proof state:
case associator_hom_inv
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ c✝ d✝ : B
f✝ : Hom a✝ b✝
g✝ : Hom b✝ c✝
h✝ : Hom c✝ d✝
⊢ (α_ (liftHom F f✝) (liftHom F g✝) (liftHom F h✝)).hom ≫ (α_ (liftHom F f✝) (liftHom F g✝) (liftHom F h✝)).inv =
    𝟙 ((liftHom F f✝ ≫ liftHom F g✝) ≫ liftHom F h✝)

Next tactic:
aesop_cat
theorem liftHom₂_congr {a b : FreeBicategory B} {f g : a ⟶ b} {η θ : Hom₂ f g} (H : Rel η θ) :
    liftHom₂ F η = liftHom₂ F θ := by induction H <;> (

Proof state:
case associator_inv_hom
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ c✝ d✝ : B
f✝ : Hom a✝ b✝
g✝ : Hom b✝ c✝
h✝ : Hom c✝ d✝
⊢ liftHom₂ F (Hom₂.vcomp (Hom₂.associator_inv f✝ g✝ h✝) (Hom₂.associator f✝ g✝ h✝)) =
    liftHom₂ F (Hom₂.id (Hom.comp f✝ (Hom.comp g✝ h✝)))

Next tactic:
dsimp [liftHom₂]
theorem liftHom₂_congr {a b : FreeBicategory B} {f g : a ⟶ b} {η θ : Hom₂ f g} (H : Rel η θ) :
    liftHom₂ F η = liftHom₂ F θ := by induction H <;> (dsimp [liftHom₂]; 

Proof state:
case associator_inv_hom
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ c✝ d✝ : B
f✝ : Hom a✝ b✝
g✝ : Hom b✝ c✝
h✝ : Hom c✝ d✝
⊢ (α_ (liftHom F f✝) (liftHom F g✝) (liftHom F h✝)).inv ≫ (α_ (liftHom F f✝) (liftHom F g✝) (liftHom F h✝)).hom =
    𝟙 (liftHom F f✝ ≫ liftHom F g✝ ≫ liftHom F h✝)

Next tactic:
aesop_cat
theorem liftHom₂_congr {a b : FreeBicategory B} {f g : a ⟶ b} {η θ : Hom₂ f g} (H : Rel η θ) :
    liftHom₂ F η = liftHom₂ F θ := by induction H <;> (

Proof state:
case left_unitor_hom_inv
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ : B
f✝ : Hom a✝ b✝
⊢ liftHom₂ F (Hom₂.vcomp (Hom₂.left_unitor f✝) (Hom₂.left_unitor_inv f✝)) =
    liftHom₂ F (Hom₂.id (Hom.comp (Hom.id a✝) f✝))

Next tactic:
dsimp [liftHom₂]
theorem liftHom₂_congr {a b : FreeBicategory B} {f g : a ⟶ b} {η θ : Hom₂ f g} (H : Rel η θ) :
    liftHom₂ F η = liftHom₂ F θ := by induction H <;> (dsimp [liftHom₂]; 

Proof state:
case left_unitor_hom_inv
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ : B
f✝ : Hom a✝ b✝
⊢ (λ_ (liftHom F f✝)).hom ≫ (λ_ (liftHom F f✝)).inv = 𝟙 (𝟙 (F.obj a✝) ≫ liftHom F f✝)

Next tactic:
aesop_cat
theorem liftHom₂_congr {a b : FreeBicategory B} {f g : a ⟶ b} {η θ : Hom₂ f g} (H : Rel η θ) :
    liftHom₂ F η = liftHom₂ F θ := by induction H <;> (

Proof state:
case left_unitor_inv_hom
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ : B
f✝ : Hom a✝ b✝
⊢ liftHom₂ F (Hom₂.vcomp (Hom₂.left_unitor_inv f✝) (Hom₂.left_unitor f✝)) = liftHom₂ F (Hom₂.id f✝)

Next tactic:
dsimp [liftHom₂]
theorem liftHom₂_congr {a b : FreeBicategory B} {f g : a ⟶ b} {η θ : Hom₂ f g} (H : Rel η θ) :
    liftHom₂ F η = liftHom₂ F θ := by induction H <;> (dsimp [liftHom₂]; 

Proof state:
case left_unitor_inv_hom
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ : B
f✝ : Hom a✝ b✝
⊢ (λ_ (liftHom F f✝)).inv ≫ (λ_ (liftHom F f✝)).hom = 𝟙 (liftHom F f✝)

Next tactic:
aesop_cat
theorem liftHom₂_congr {a b : FreeBicategory B} {f g : a ⟶ b} {η θ : Hom₂ f g} (H : Rel η θ) :
    liftHom₂ F η = liftHom₂ F θ := by induction H <;> (

Proof state:
case right_unitor_hom_inv
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ : B
f✝ : Hom a✝ b✝
⊢ liftHom₂ F (Hom₂.vcomp (Hom₂.right_unitor f✝) (Hom₂.right_unitor_inv f✝)) =
    liftHom₂ F (Hom₂.id (Hom.comp f✝ (Hom.id b✝)))

Next tactic:
dsimp [liftHom₂]
theorem liftHom₂_congr {a b : FreeBicategory B} {f g : a ⟶ b} {η θ : Hom₂ f g} (H : Rel η θ) :
    liftHom₂ F η = liftHom₂ F θ := by induction H <;> (dsimp [liftHom₂]; 

Proof state:
case right_unitor_hom_inv
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ : B
f✝ : Hom a✝ b✝
⊢ (ρ_ (liftHom F f✝)).hom ≫ (ρ_ (liftHom F f✝)).inv = 𝟙 (liftHom F f✝ ≫ 𝟙 (F.obj b✝))

Next tactic:
aesop_cat
theorem liftHom₂_congr {a b : FreeBicategory B} {f g : a ⟶ b} {η θ : Hom₂ f g} (H : Rel η θ) :
    liftHom₂ F η = liftHom₂ F θ := by induction H <;> (

Proof state:
case right_unitor_inv_hom
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ : B
f✝ : Hom a✝ b✝
⊢ liftHom₂ F (Hom₂.vcomp (Hom₂.right_unitor_inv f✝) (Hom₂.right_unitor f✝)) = liftHom₂ F (Hom₂.id f✝)

Next tactic:
dsimp [liftHom₂]
theorem liftHom₂_congr {a b : FreeBicategory B} {f g : a ⟶ b} {η θ : Hom₂ f g} (H : Rel η θ) :
    liftHom₂ F η = liftHom₂ F θ := by induction H <;> (dsimp [liftHom₂]; 

Proof state:
case right_unitor_inv_hom
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ : B
f✝ : Hom a✝ b✝
⊢ (ρ_ (liftHom F f✝)).inv ≫ (ρ_ (liftHom F f✝)).hom = 𝟙 (liftHom F f✝)

Next tactic:
aesop_cat
theorem liftHom₂_congr {a b : FreeBicategory B} {f g : a ⟶ b} {η θ : Hom₂ f g} (H : Rel η θ) :
    liftHom₂ F η = liftHom₂ F θ := by induction H <;> (

Proof state:
case pentagon
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ c✝ d✝ e✝ : B
f✝ : Hom a✝ b✝
g✝ : Hom b✝ c✝
h✝ : Hom c✝ d✝
i✝ : Hom d✝ e✝
⊢ liftHom₂ F
      (Hom₂.vcomp (Hom₂.whisker_right i✝ (Hom₂.associator f✝ g✝ h✝))
        (Hom₂.vcomp (Hom₂.associator f✝ (Hom.comp g✝ h✝) i✝) (Hom₂.whisker_left f✝ (Hom₂.associator g✝ h✝ i✝)))) =
    liftHom₂ F (Hom₂.vcomp (Hom₂.associator (Hom.comp f✝ g✝) h✝ i✝) (Hom₂.associator f✝ g✝ (Hom.comp h✝ i✝)))

Next tactic:
dsimp [liftHom₂]
theorem liftHom₂_congr {a b : FreeBicategory B} {f g : a ⟶ b} {η θ : Hom₂ f g} (H : Rel η θ) :
    liftHom₂ F η = liftHom₂ F θ := by induction H <;> (dsimp [liftHom₂]; 

Proof state:
case pentagon
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ c✝ d✝ e✝ : B
f✝ : Hom a✝ b✝
g✝ : Hom b✝ c✝
h✝ : Hom c✝ d✝
i✝ : Hom d✝ e✝
⊢ (α_ (liftHom F f✝) (liftHom F g✝) (liftHom F h✝)).hom ▷ liftHom F i✝ ≫
      (α_ (liftHom F f✝) (liftHom F g✝ ≫ liftHom F h✝) (liftHom F i✝)).hom ≫
        liftHom F f✝ ◁ (α_ (liftHom F g✝) (liftHom F h✝) (liftHom F i✝)).hom =
    (α_ (liftHom F f✝ ≫ liftHom F g✝) (liftHom F h✝) (liftHom F i✝)).hom ≫
      (α_ (liftHom F f✝) (liftHom F g✝) (liftHom F h✝ ≫ liftHom F i✝)).hom

Next tactic:
aesop_cat
theorem liftHom₂_congr {a b : FreeBicategory B} {f g : a ⟶ b} {η θ : Hom₂ f g} (H : Rel η θ) :
    liftHom₂ F η = liftHom₂ F θ := by induction H <;> (

Proof state:
case triangle
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ c✝ : B
f✝ : Hom a✝ b✝
g✝ : Hom b✝ c✝
⊢ liftHom₂ F (Hom₂.vcomp (Hom₂.associator f✝ (Hom.id b✝) g✝) (Hom₂.whisker_left f✝ (Hom₂.left_unitor g✝))) =
    liftHom₂ F (Hom₂.whisker_right g✝ (Hom₂.right_unitor f✝))

Next tactic:
dsimp [liftHom₂]
theorem liftHom₂_congr {a b : FreeBicategory B} {f g : a ⟶ b} {η θ : Hom₂ f g} (H : Rel η θ) :
    liftHom₂ F η = liftHom₂ F θ := by induction H <;> (dsimp [liftHom₂]; 

Proof state:
case triangle
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g : a ⟶ b
η θ : Hom₂ f g
a✝ b✝ c✝ : B
f✝ : Hom a✝ b✝
g✝ : Hom b✝ c✝
⊢ (α_ (liftHom F f✝) (𝟙 (F.obj b✝)) (liftHom F g✝)).hom ≫ liftHom F f✝ ◁ (λ_ (liftHom F g✝)).hom =
    (ρ_ (liftHom F f✝)).hom ▷ liftHom F g✝

Next tactic:
aesop_cat
/-- A prefunctor from a quiver `B` to a bicategory `C` can be lifted to a pseudofunctor from
`free_bicategory B` to `C`.
-/
@[simps]
def lift : Pseudofunctor (FreeBicategory B) C where
  obj := F.obj
  map := liftHom F
  mapId a := Iso.refl _
  mapComp f g := Iso.refl _
  map₂ := Quot.lift (liftHom₂ F) fun η θ H => liftHom₂_congr F H
  -- Porting note: We'd really prefer not to be doing this by hand.
  -- in mathlib3 `tidy` did these inductions for us.
  map₂_comp := by
    

Proof state:
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
⊢ ∀ {a b : FreeBicategory B} {f g h : a ⟶ b} (η : f ⟶ g) (θ : g ⟶ h),
    PrelaxFunctor.map₂
        { toPrefunctor := { obj := F.obj, map := fun {X Y} => liftHom F },
          map₂ := fun {a b} {f g} =>
            Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ f g), Rel η θ → liftHom₂ F η = liftHom₂ F θ) }
        (η ≫ θ) =
      PrelaxFunctor.map₂
          { toPrefunctor := { obj := F.obj, map := fun {X Y} => liftHom F },
            map₂ := fun {a b} {f g} =>
              Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ f g), Rel η θ → liftHom₂ F η = liftHom₂ F θ) }
          η ≫
        PrelaxFunctor.map₂
          { toPrefunctor := { obj := F.obj, map := fun {X Y} => liftHom F },
            map₂ := fun {a b} {f g} =>
              Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ f g), Rel η θ → liftHom₂ F η = liftHom₂ F θ) }
          θ

Next tactic:
intros a b f g h η θ
/-- A prefunctor from a quiver `B` to a bicategory `C` can be lifted to a pseudofunctor from
`free_bicategory B` to `C`.
-/
@[simps]
def lift : Pseudofunctor (FreeBicategory B) C where
  obj := F.obj
  map := liftHom F
  mapId a := Iso.refl _
  mapComp f g := Iso.refl _
  map₂ := Quot.lift (liftHom₂ F) fun η θ H => liftHom₂_congr F H
  -- Porting note: We'd really prefer not to be doing this by hand.
  -- in mathlib3 `tidy` did these inductions for us.
  map₂_comp := by
    intros a b f g h η θ
    

Proof state:
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g h : a ⟶ b
η : f ⟶ g
θ : g ⟶ h
⊢ PrelaxFunctor.map₂
      { toPrefunctor := { obj := F.obj, map := fun {X Y} => liftHom F },
        map₂ := fun {a b} {f g} =>
          Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ f g), Rel η θ → liftHom₂ F η = liftHom₂ F θ) }
      (η ≫ θ) =
    PrelaxFunctor.map₂
        { toPrefunctor := { obj := F.obj, map := fun {X Y} => liftHom F },
          map₂ := fun {a b} {f g} =>
            Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ f g), Rel η θ → liftHom₂ F η = liftHom₂ F θ) }
        η ≫
      PrelaxFunctor.map₂
        { toPrefunctor := { obj := F.obj, map := fun {X Y} => liftHom F },
          map₂ := fun {a b} {f g} =>
            Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ f g), Rel η θ → liftHom₂ F η = liftHom₂ F θ) }
        θ

Next tactic:
apply Quot.rec _ _ η
/-- A prefunctor from a quiver `B` to a bicategory `C` can be lifted to a pseudofunctor from
`free_bicategory B` to `C`.
-/
@[simps]
def lift : Pseudofunctor (FreeBicategory B) C where
  obj := F.obj
  map := liftHom F
  mapId a := Iso.refl _
  mapComp f g := Iso.refl _
  map₂ := Quot.lift (liftHom₂ F) fun η θ H => liftHom₂_congr F H
  -- Porting note: We'd really prefer not to be doing this by hand.
  -- in mathlib3 `tidy` did these inductions for us.
  map₂_comp := by
    intros a b f g h η θ
    apply Quot.rec _ _ η
    · 

Proof state:
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g h : a ⟶ b
η : f ⟶ g
θ : g ⟶ h
⊢ ∀ (a_1 : Hom₂ f g),
    PrelaxFunctor.map₂
        { toPrefunctor := { obj := F.obj, map := fun {X Y} => liftHom F },
          map₂ := fun {a b} {f g} =>
            Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ f g), Rel η θ → liftHom₂ F η = liftHom₂ F θ) }
        (Quot.mk Rel a_1 ≫ θ) =
      PrelaxFunctor.map₂
          { toPrefunctor := { obj := F.obj, map := fun {X Y} => liftHom F },
            map₂ := fun {a b} {f g} =>
              Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ f g), Rel η θ → liftHom₂ F η = liftHom₂ F θ) }
          (Quot.mk Rel a_1) ≫
        PrelaxFunctor.map₂
          { toPrefunctor := { obj := F.obj, map := fun {X Y} => liftHom F },
            map₂ := fun {a b} {f g} =>
              Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ f g), Rel η θ → liftHom₂ F η = liftHom₂ F θ) }
          θ

Next tactic:
intro η
/-- A prefunctor from a quiver `B` to a bicategory `C` can be lifted to a pseudofunctor from
`free_bicategory B` to `C`.
-/
@[simps]
def lift : Pseudofunctor (FreeBicategory B) C where
  obj := F.obj
  map := liftHom F
  mapId a := Iso.refl _
  mapComp f g := Iso.refl _
  map₂ := Quot.lift (liftHom₂ F) fun η θ H => liftHom₂_congr F H
  -- Porting note: We'd really prefer not to be doing this by hand.
  -- in mathlib3 `tidy` did these inductions for us.
  map₂_comp := by
    intros a b f g h η θ
    apply Quot.rec _ _ η
    · intro η
      

Proof state:
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g h : a ⟶ b
η✝ : f ⟶ g
θ : g ⟶ h
η : Hom₂ f g
⊢ PrelaxFunctor.map₂
      { toPrefunctor := { obj := F.obj, map := fun {X Y} => liftHom F },
        map₂ := fun {a b} {f g} =>
          Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ f g), Rel η θ → liftHom₂ F η = liftHom₂ F θ) }
      (Quot.mk Rel η ≫ θ) =
    PrelaxFunctor.map₂
        { toPrefunctor := { obj := F.obj, map := fun {X Y} => liftHom F },
          map₂ := fun {a b} {f g} =>
            Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ f g), Rel η θ → liftHom₂ F η = liftHom₂ F θ) }
        (Quot.mk Rel η) ≫
      PrelaxFunctor.map₂
        { toPrefunctor := { obj := F.obj, map := fun {X Y} => liftHom F },
          map₂ := fun {a b} {f g} =>
            Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ f g), Rel η θ → liftHom₂ F η = liftHom₂ F θ) }
        θ

Next tactic:
apply Quot.rec _ _ θ
/-- A prefunctor from a quiver `B` to a bicategory `C` can be lifted to a pseudofunctor from
`free_bicategory B` to `C`.
-/
@[simps]
def lift : Pseudofunctor (FreeBicategory B) C where
  obj := F.obj
  map := liftHom F
  mapId a := Iso.refl _
  mapComp f g := Iso.refl _
  map₂ := Quot.lift (liftHom₂ F) fun η θ H => liftHom₂_congr F H
  -- Porting note: We'd really prefer not to be doing this by hand.
  -- in mathlib3 `tidy` did these inductions for us.
  map₂_comp := by
    intros a b f g h η θ
    apply Quot.rec _ _ η
    · intro η
      apply Quot.rec _ _ θ
      · 

Proof state:
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g h : a ⟶ b
η✝ : f ⟶ g
θ : g ⟶ h
η : Hom₂ f g
⊢ ∀ (a_1 : Hom₂ g h),
    PrelaxFunctor.map₂
        { toPrefunctor := { obj := F.obj, map := fun {X Y} => liftHom F },
          map₂ := fun {a b} {f g} =>
            Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ f g), Rel η θ → liftHom₂ F η = liftHom₂ F θ) }
        (Quot.mk Rel η ≫ Quot.mk Rel a_1) =
      PrelaxFunctor.map₂
          { toPrefunctor := { obj := F.obj, map := fun {X Y} => liftHom F },
            map₂ := fun {a b} {f g} =>
              Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ f g), Rel η θ → liftHom₂ F η = liftHom₂ F θ) }
          (Quot.mk Rel η) ≫
        PrelaxFunctor.map₂
          { toPrefunctor := { obj := F.obj, map := fun {X Y} => liftHom F },
            map₂ := fun {a b} {f g} =>
              Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ f g), Rel η θ → liftHom₂ F η = liftHom₂ F θ) }
          (Quot.mk Rel a_1)

Next tactic:
intro θ
/-- A prefunctor from a quiver `B` to a bicategory `C` can be lifted to a pseudofunctor from
`free_bicategory B` to `C`.
-/
@[simps]
def lift : Pseudofunctor (FreeBicategory B) C where
  obj := F.obj
  map := liftHom F
  mapId a := Iso.refl _
  mapComp f g := Iso.refl _
  map₂ := Quot.lift (liftHom₂ F) fun η θ H => liftHom₂_congr F H
  -- Porting note: We'd really prefer not to be doing this by hand.
  -- in mathlib3 `tidy` did these inductions for us.
  map₂_comp := by
    intros a b f g h η θ
    apply Quot.rec _ _ η
    · intro η
      apply Quot.rec _ _ θ
      · intro θ; 

Proof state:
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g h : a ⟶ b
η✝ : f ⟶ g
θ✝ : g ⟶ h
η : Hom₂ f g
θ : Hom₂ g h
⊢ PrelaxFunctor.map₂
      { toPrefunctor := { obj := F.obj, map := fun {X Y} => liftHom F },
        map₂ := fun {a b} {f g} =>
          Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ f g), Rel η θ → liftHom₂ F η = liftHom₂ F θ) }
      (Quot.mk Rel η ≫ Quot.mk Rel θ) =
    PrelaxFunctor.map₂
        { toPrefunctor := { obj := F.obj, map := fun {X Y} => liftHom F },
          map₂ := fun {a b} {f g} =>
            Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ f g), Rel η θ → liftHom₂ F η = liftHom₂ F θ) }
        (Quot.mk Rel η) ≫
      PrelaxFunctor.map₂
        { toPrefunctor := { obj := F.obj, map := fun {X Y} => liftHom F },
          map₂ := fun {a b} {f g} =>
            Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ f g), Rel η θ → liftHom₂ F η = liftHom₂ F θ) }
        (Quot.mk Rel θ)

Next tactic:
rfl
/-- A prefunctor from a quiver `B` to a bicategory `C` can be lifted to a pseudofunctor from
`free_bicategory B` to `C`.
-/
@[simps]
def lift : Pseudofunctor (FreeBicategory B) C where
  obj := F.obj
  map := liftHom F
  mapId a := Iso.refl _
  mapComp f g := Iso.refl _
  map₂ := Quot.lift (liftHom₂ F) fun η θ H => liftHom₂_congr F H
  -- Porting note: We'd really prefer not to be doing this by hand.
  -- in mathlib3 `tidy` did these inductions for us.
  map₂_comp := by
    intros a b f g h η θ
    apply Quot.rec _ _ η
    · intro η
      apply Quot.rec _ _ θ
      · intro θ; rfl
      · 

Proof state:
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b : FreeBicategory B
f g h : a ⟶ b
η✝ : f ⟶ g
θ : g ⟶ h
η : Hom₂ f g
⊢ ∀ (a_1 b_1 : Hom₂ g h) (p : Rel a_1 b_1),
    (_ :
        PrelaxFunctor.map₂
            { toPrefunctor := { obj := F.obj, map := fun {X Y} => liftHom F },
              map₂ := fun {a b} {f g} =>
                Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ f g), Rel η θ → liftHom₂ F η = liftHom₂ F θ) }
            (Quot.mk Rel η ≫ Quot.mk Rel b_1) =
          PrelaxFunctor.map₂
              { toPrefunctor := { obj := F.obj, map := fun {X Y} => liftHom F },
                map₂ := fun {a b} {f g} =>
                  Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ f g), Rel η θ → liftHom₂ F η = liftHom₂ F θ) }
              (Quot.mk Rel η) ≫
            PrelaxFunctor.map₂
              { toPrefunctor := { obj := F.obj, map := fun {X Y} => liftHom F },
                map₂ := fun {a b} {f g} =>
                  Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ f g), Rel η θ → liftHom₂ F η = liftHom₂ F θ) }
              (Quot.mk Rel b_1)) =
      (_ :
        PrelaxFunctor.map₂
            { toPrefunctor := { obj := F.obj, map := fun {X Y} => liftHom F },
              map₂ := fun {a b} {f g} =>
                Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ f g), Rel η θ → liftHom₂ F η = liftHom₂ F θ) }
            (Quot.mk Rel η ≫ Quot.mk Rel b_1) =
          PrelaxFunctor.map₂
            { toPrefunctor := { obj := F.obj, map := fun {X Y} => liftHom F },
              map₂ := fun {a b} {f g} =>
                Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ f g), Rel η θ → liftHom₂ F η = liftHom₂ F θ) }
            (Quot.mk Rel η ≫ Quot.mk Rel b_1))

Next tactic:
intros