/-- 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
      · intros; rfl
    · intros; rfl
  -- Porting note: still borked from here. The infoview doesn't update properly for me.
  map₂_whisker_left := by
    intro a b c f g h η
    apply Quot.rec _ _ η
    · intros; aesop_cat
    · 

Proof state:
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a b c : FreeBicategory B
f : a ⟶ b
g h : b ⟶ c
η : g ⟶ h
⊢ ∀ (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 θ) }
            (f ◁ Quot.mk Rel b_1) =
          ((fun {a b c} f g =>
                  Iso.refl
                    ((↑{ 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 θ) }).map
                      (f ≫ g)))
                f g).hom ≫
            (↑{ 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 θ) }).map
                  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 θ) }
                  (Quot.mk Rel b_1) ≫
              ((fun {a b c} f g =>
                    Iso.refl
                      ((↑{ 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 θ) }).map
                        (f ≫ g)))
                  f h).inv) =
      (_ :
        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 θ) }
            (f ◁ Quot.mk Rel b_1) =
          ((fun {a b c} f g =>
                  Iso.refl
                    ((↑{ 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 θ) }).map
                      (f ≫ g)))
                f g).hom ≫
            (↑{ 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 θ) }).map
                  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 θ) }
                  (Quot.mk Rel b_1) ≫
              ((fun {a b c} f g =>
                    Iso.refl
                      ((↑{ 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 θ) }).map
                        (f ≫ g)))
                  f h).inv)

Next tactic:
intros