/-- 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
    · intros; 

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✝ b✝ : Hom₂ g h
p✝ : Rel a✝ b✝
⊢ (_ :
      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✝) =
        ((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✝) ≫
            ((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✝) =
        ((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✝) ≫
            ((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:
rfl