l3lab/ntp-mathlib huggingface dataset:
/-- 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; 

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✝ 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 θ) }
          (Quot.mk Rel η ≫ Quot.mk Rel 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 θ) }
            (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✝)) =
    (_ :
      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✝) =
        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✝))

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
      · intros; 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
⊢ ∀ (a_1 b_1 : Hom₂ f g) (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 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 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 θ) }
              θ) =
      (_ :
        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 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 θ) }
              θ)

Next tactic:
intros
/-- 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; 

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✝ b✝ : Hom₂ f g
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 θ) }
          (Quot.mk Rel 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 θ) }
            (Quot.mk Rel 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 θ) }
            θ) =
    (_ :
      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✝ ≫ θ) =
        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✝) ≫
          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:
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
      · intros; rfl
    · intros; rfl
  -- Porting note: still borked from here. The infoview doesn't update properly for me.
  map₂_whisker_left := by
    

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),
    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 ◁ η) =
      ((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 θ) }
              η ≫
          ((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:
intro a b c 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 η θ
    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 η
    

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
⊢ 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 ◁ η) =
    ((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 θ) }
            η ≫
        ((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:
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 _ _ θ
      · 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 _ _ η
    · 

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 : 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 θ) }
        (f ◁ Quot.mk Rel a_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 a_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
/-- 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; 

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✝ : 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 θ) }
      (f ◁ Quot.mk Rel a✝) =
    ((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 a✝) ≫
        ((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:
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
    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; rfl
  map₂_whisker_right := by 

Proof state:
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
⊢ ∀ {a b c : FreeBicategory B} {f g : a ⟶ b} (η : f ⟶ g) (h : b ⟶ c),
    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 θ) }
        (η ▷ h) =
      ((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).hom ≫
        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 θ) }
              η ▷
            (↑{ 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
              h ≫
          ((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)))
              g h).inv

Next tactic:
intro _ _ _ _ _ η 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 η θ
    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; rfl
  map₂_whisker_right := by intro _ _ _ _ _ η h; 

Proof state:
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a✝ b✝ c✝ : FreeBicategory B
f✝ g✝ : a✝ ⟶ b✝
η : f✝ ⟶ g✝
h : b✝ ⟶ c✝
⊢ 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 θ) }
      (η ▷ h) =
    ((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).hom ≫
      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 θ) }
            η ▷
          (↑{ 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
            h ≫
        ((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)))
            g✝ h).inv

Next tactic:
dsimp
/-- 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; rfl
  map₂_whisker_right := by intro _ _ _ _ _ η h; dsimp; 

Proof state:
B : Type u₁
inst✝¹ : Quiver B
C : Type u₂
inst✝ : Bicategory C
F : B ⥤q C
a✝ b✝ c✝ : FreeBicategory B
f✝ g✝ : a✝ ⟶ b✝
η : f✝ ⟶ g✝
h : b✝ ⟶ c✝
⊢ Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ (f✝ ≫ h) (g✝ ≫ h)), Rel η θ → liftHom₂ F η = liftHom₂ F θ) (η ▷ h) =
    𝟙 (liftHom F f✝ ≫ liftHom F h) ≫
      Quot.lift (liftHom₂ F) (_ : ∀ (η θ : Hom₂ f✝ g✝), Rel η θ → liftHom₂ F η = liftHom₂ F θ) η ▷ liftHom F h ≫
        𝟙 (liftHom F g✝ ≫ liftHom F h)

Next tactic:
apply Quot.rec _ _ η