Theorem: CategoryTheory.FreeBicategory.lift_toPrelaxFunctor_toPrelaxFunctorStruct_map₂
File: Mathlib/CategoryTheory/Bicategory/Free.lean

Proof steps:
state_before: 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),
    { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯ }.map₂ (η ≫ θ) =
      { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯ }.map₂ η ≫
        { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯ }.map₂ θ
state_after: 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
⊢ { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯ }.map₂ (η ≫ θ) =
    { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯ }.map₂ η ≫
      { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯ }.map₂ θ
tactic: intros a b f g h η θ
state_before: 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
⊢ { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯ }.map₂ (η ≫ θ) =
    { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯ }.map₂ η ≫
      { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯ }.map₂ θ
state_after: 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),
    { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯ }.map₂
        (Quot.mk Rel a_1 ≫ θ) =
      { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯ }.map₂
          (Quot.mk Rel a_1) ≫
        { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯ }.map₂ θ

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), ⋯ = ⋯
tactic: apply Quot.rec _ _ η
state_before: 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),
    { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯, map₂_id := ⋯,
            map₂_comp := ⋯ }.map₂
        (f ◁ η) =
      ((fun {a b c} f g =>
              Iso.refl
                ({ obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯,
                      map₂_id := ⋯, map₂_comp := ⋯ }.map
                  (f ≫ g)))
            f g).hom ≫
        { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯,
                  map₂_id := ⋯, map₂_comp := ⋯ }.map
              f ◁
            { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯,
                  map₂_id := ⋯, map₂_comp := ⋯ }.map₂
              η ≫
          ((fun {a b c} f g =>
                Iso.refl
                  ({ obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯,
                        map₂_id := ⋯, map₂_comp := ⋯ }.map
                    (f ≫ g)))
              f h).inv
state_after: 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
⊢ { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯, map₂_id := ⋯,
          map₂_comp := ⋯ }.map₂
      (f ◁ η) =
    ((fun {a b c} f g =>
            Iso.refl
              ({ obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯,
                    map₂_id := ⋯, map₂_comp := ⋯ }.map
                (f ≫ g)))
          f g).hom ≫
      { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯, map₂_id := ⋯,
                map₂_comp := ⋯ }.map
            f ◁
          { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯,
                map₂_id := ⋯, map₂_comp := ⋯ }.map₂
            η ≫
        ((fun {a b c} f g =>
              Iso.refl
                ({ obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯,
                      map₂_id := ⋯, map₂_comp := ⋯ }.map
                  (f ≫ g)))
            f h).inv
tactic: intro a b c f g h η
state_before: 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
⊢ { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯, map₂_id := ⋯,
          map₂_comp := ⋯ }.map₂
      (f ◁ η) =
    ((fun {a b c} f g =>
            Iso.refl
              ({ obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯,
                    map₂_id := ⋯, map₂_comp := ⋯ }.map
                (f ≫ g)))
          f g).hom ≫
      { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯, map₂_id := ⋯,
                map₂_comp := ⋯ }.map
            f ◁
          { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯,
                map₂_id := ⋯, map₂_comp := ⋯ }.map₂
            η ≫
        ((fun {a b c} f g =>
              Iso.refl
                ({ obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯,
                      map₂_id := ⋯, map₂_comp := ⋯ }.map
                  (f ≫ g)))
            f h).inv
state_after: 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),
    { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯, map₂_id := ⋯,
            map₂_comp := ⋯ }.map₂
        (f ◁ Quot.mk Rel a_1) =
      ((fun {a b c} f g =>
              Iso.refl
                ({ obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯,
                      map₂_id := ⋯, map₂_comp := ⋯ }.map
                  (f ≫ g)))
            f g).hom ≫
        { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯,
                  map₂_id := ⋯, map₂_comp := ⋯ }.map
              f ◁
            { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯,
                  map₂_id := ⋯, map₂_comp := ⋯ }.map₂
              (Quot.mk Rel a_1) ≫
          ((fun {a b c} f g =>
                Iso.refl
                  ({ obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯,
                        map₂_id := ⋯, map₂_comp := ⋯ }.map
                    (f ≫ g)))
              f h).inv

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), ⋯ = ⋯
tactic: apply Quot.rec _ _ η
state_before: 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),
    { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯, map₂_id := ⋯,
            map₂_comp := ⋯ }.map₂
        (η ▷ h) =
      ((fun {a b c} f g =>
              Iso.refl
                ({ obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯,
                      map₂_id := ⋯, map₂_comp := ⋯ }.map
                  (f ≫ g)))
            f h).hom ≫
        { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯,
                  map₂_id := ⋯, map₂_comp := ⋯ }.map₂
              η ▷
            { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯,
                  map₂_id := ⋯, map₂_comp := ⋯ }.map
              h ≫
          ((fun {a b c} f g =>
                Iso.refl
                  ({ obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯,
                        map₂_id := ⋯, map₂_comp := ⋯ }.map
                    (f ≫ g)))
              g h).inv
state_after: 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✝
⊢ { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯, map₂_id := ⋯,
          map₂_comp := ⋯ }.map₂
      (η ▷ h) =
    ((fun {a b c} f g =>
            Iso.refl
              ({ obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯,
                    map₂_id := ⋯, map₂_comp := ⋯ }.map
                (f ≫ g)))
          f✝ h).hom ≫
      { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯, map₂_id := ⋯,
                map₂_comp := ⋯ }.map₂
            η ▷
          { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯,
                map₂_id := ⋯, map₂_comp := ⋯ }.map
            h ≫
        ((fun {a b c} f g =>
              Iso.refl
                ({ obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯,
                      map₂_id := ⋯, map₂_comp := ⋯ }.map
                  (f ≫ g)))
            g✝ h).inv
tactic: intro _ _ _ _ _ η h
state_before: 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✝
⊢ { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯, map₂_id := ⋯,
          map₂_comp := ⋯ }.map₂
      (η ▷ h) =
    ((fun {a b c} f g =>
            Iso.refl
              ({ obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯,
                    map₂_id := ⋯, map₂_comp := ⋯ }.map
                (f ≫ g)))
          f✝ h).hom ≫
      { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯, map₂_id := ⋯,
                map₂_comp := ⋯ }.map₂
            η ▷
          { obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯,
                map₂_id := ⋯, map₂_comp := ⋯ }.map
            h ≫
        ((fun {a b c} f g =>
              Iso.refl
                ({ obj := F.obj, map := fun {X Y} => liftHom F, map₂ := fun {a b} {f g} => Quot.lift (liftHom₂ F) ⋯,
                      map₂_id := ⋯, map₂_comp := ⋯ }.map
                  (f ≫ g)))
            g✝ h).inv
state_after: 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) ⋯ (η ▷ h) =
    𝟙 (liftHom F f✝ ≫ liftHom F h) ≫ Quot.lift (liftHom₂ F) ⋯ η ▷ liftHom F h ≫ 𝟙 (liftHom F g✝ ≫ liftHom F h)
tactic: dsimp
state_before: 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) ⋯ (η ▷ h) =
    𝟙 (liftHom F f✝ ≫ liftHom F h) ≫ Quot.lift (liftHom₂ F) ⋯ η ▷ liftHom F h ≫ 𝟙 (liftHom F g✝ ≫ liftHom F h)
state_after: no goals
tactic: apply Quot.rec _ _ η <;> aesop_cat