/-- composition of qpfs gives another qpf -/
def comp : QPF (Functor.Comp F₂ F₁) where
  P := PFunctor.comp q₂.P q₁.P
  abs {α} := by
    dsimp [Functor.Comp]
    intro p
    exact abs ⟨p.1.1, fun x => abs ⟨p.1.2 x, fun y => p.2 ⟨x, y⟩⟩⟩
  repr {α} := by
    dsimp [Functor.Comp]
    intro y
    refine' ⟨⟨(repr y).1, fun u => (repr ((repr y).2 u)).1⟩, _⟩
    dsimp [PFunctor.comp]
    intro x
    exact (repr ((repr y).2 x.1)).snd x.2
  abs_repr {α} := by
    dsimp [Functor.Comp]
    intro x
    conv =>
      rhs
      rw [← abs_repr x]
    cases' h : repr x with a f
    dsimp
    congr with x
    cases' h' : repr (f x) with b g
    dsimp; rw [← h', abs_repr]
  abs_map {α β} f := by
    dsimp (config := { unfoldPartialApp := true }) [Functor.Comp, PFunctor.comp]
    intro p
    cases' p with a g; dsimp
    cases' a with b h; dsimp
    symm
    trans
    

Proof state:
F₂ : Type u → Type u
inst✝¹ : Functor F₂
q₂ : QPF F₂
F₁ : Type u → Type u
inst✝ : Functor F₁
q₁ : QPF F₁
α β : Type u
f : α → β
b : (P F₂).A
h : PFunctor.B (P F₂) b → (P F₁).A
g :
  PFunctor.B
      { A := (a₂ : (P F₂).A) × (PFunctor.B (P F₂) a₂ → (P F₁).A),
        B := fun a₂a₁ => (u : PFunctor.B (P F₂) a₂a₁.fst) × PFunctor.B (P F₁) (Sigma.snd a₂a₁ u) }
      { fst := b, snd := h } →
    α
⊢ f <$> abs { fst := b, snd := fun x => abs { fst := h x, snd := fun y => g { fst := x, snd := y } } } = ?m.45358
F₂ : Type u → Type u
inst✝¹ : Functor F₂
q₂ : QPF F₂
F₁ : Type u → Type u
inst✝ : Functor F₁
q₁ : QPF F₁
α β : Type u
f : α → β
b : (P F₂).A
h : PFunctor.B (P F₂) b → (P F₁).A
g :
  PFunctor.B
      { A := (a₂ : (P F₂).A) × (PFunctor.B (P F₂) a₂ → (P F₁).A),
        B := fun a₂a₁ => (u : PFunctor.B (P F₂) a₂a₁.fst) × PFunctor.B (P F₁) (Sigma.snd a₂a₁ u) }
      { fst := b, snd := h } →
    α
⊢ ?m.45358 =
    abs
      {
        fst :=
          (PFunctor.map
                { A := (a₂ : (P F₂).A) × (PFunctor.B (P F₂) a₂ → (P F₁).A),
                  B := fun a₂a₁ => (u : PFunctor.B (P F₂) a₂a₁.fst) × PFunctor.B (P F₁) (Sigma.snd a₂a₁ u) }
                f { fst := { fst := b, snd := h }, snd := g }).fst.fst,
        snd := fun x =>
          abs
            {
              fst :=
                Sigma.snd
                  (PFunctor.map
                      { A := (a₂ : (P F₂).A) × (PFunctor.B (P F₂) a₂ → (P F₁).A),
                        B := fun a₂a₁ => (u : PFunctor.B (P F₂) a₂a₁.fst) × PFunctor.B (P F₁) (Sigma.snd a₂a₁ u) }
                      f { fst := { fst := b, snd := h }, snd := g }).fst
                  x,
              snd := fun y =>
                Sigma.snd
                  (PFunctor.map
                    { A := (a₂ : (P F₂).A) × (PFunctor.B (P F₂) a₂ → (P F₁).A),
                      B := fun a₂a₁ => (u : PFunctor.B (P F₂) a₂a₁.fst) × PFunctor.B (P F₁) (Sigma.snd a₂a₁ u) }
                    f { fst := { fst := b, snd := h }, snd := g })
                  { fst := x, snd := y } } }
F₂ : Type u → Type u
inst✝¹ : Functor F₂
q₂ : QPF F₂
F₁ : Type u → Type u
inst✝ : Functor F₁
q₁ : QPF F₁
α β : Type u
f : α → β
b : (P F₂).A
h : PFunctor.B (P F₂) b → (P F₁).A
g :
  PFunctor.B
      { A := (a₂ : (P F₂).A) × (PFunctor.B (P F₂) a₂ → (P F₁).A),
        B := fun a₂a₁ => (u : PFunctor.B (P F₂) a₂a₁.fst) × PFunctor.B (P F₁) (Sigma.snd a₂a₁ u) }
      { fst := b, snd := h } →
    α
⊢ F₂ (F₁ β)

Next tactic:
symm