-- Lean 4 proof step from Mathlib.Analysis.Analytic.Composition (goal)
Goal:
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst : NontriviallyNormedField 𝕜
inst_1 : NormedAddCommGroup E
inst_2 : NormedSpace 𝕜 E
inst_3 : NormedAddCommGroup F
inst_4 : NormedSpace 𝕜 F
inst_5 : NormedAddCommGroup G
inst_6 : NormedSpace 𝕜 G
inst_7 : NormedAddCommGroup H
inst_8 : NormedSpace 𝕜 H
r : FormalMultilinearSeries 𝕜 G H
q : FormalMultilinearSeries 𝕜 F G
p : FormalMultilinearSeries 𝕜 E F
n : ℕ
v : (i : Fin n) → E
f : (a : Composition n) × Composition a.length → H :=
  fun (c : (a : Composition n) × Composition a.length) ↦
    (r c.snd (β := fun (a : Composition n) ↦ Composition a.length).length : (a : (i : Fin c.snd.length) → G) → H)
      (q.applyComposition (c.snd (β := fun (a : Composition n) ↦ Composition a.length))
        (p.applyComposition (c.fst (β := fun (a : Composition n) ↦ Composition a.length)) v))
g : (c : Composition n) × ((i : Fin c.length) → Composition (c.blocksFun i)) → H :=
  fun (c : (c : Composition n) × ((i : Fin c.length) → Composition (c.blocksFun i))) ↦
    (r c.fst (β := fun (c : Composition n) ↦ (i : Fin c.length) → Composition (c.blocksFun i)).length :
        (a : (i : Fin c.fst.length) → G) → H)
      fun (i : Fin c.fst (β := fun (c : Composition n) ↦ (i : Fin c.length) → Composition (c.blocksFun i)).length) ↦
      (q (c.snd (β := fun (c : Composition n) ↦ (i : Fin c.length) → Composition (c.blocksFun i)) i).length :
          (a : (i : Fin (c.snd i).length) → F) → G)
        (p.applyComposition (c.snd (β := fun (c : Composition n) ↦ (i : Fin c.length) → Composition (c.blocksFun i)) i)
          (v ∘
            (⇑(c.fst (β := fun (c : Composition n) ↦ (i : Fin c.length) → Composition (c.blocksFun i)).embedding i) :
              (a : Fin (c.fst.blocksFun i)) → Fin n)))
a : Composition n
b : Composition a.length
h :
  Membership.mem (γ := Finset ((a : Composition n) × Composition a.length)) Finset.univ
    (Sigma.mk (β := fun (a : Composition n) ↦ Composition a.length) a b)
i : ℕ
hi1 : i < b.length
hi2 : i < (a.gather b).length
j : ℕ
hj1 : j < b.blocksFun ⟨i, hi1⟩
hj2 :
  j <
    Composition.length (n := (a.gather b).blocksFun ⟨(↑(⟨i, hi1⟩ : Fin b.length) : ℕ), ⋯⟩)
      (a.sigmaCompositionAux b ⟨(↑(⟨i, hi1⟩ : Fin b.length) : ℕ), ⋯⟩)
k : ℕ
hk1 : k < a.blocksFun ((b.embedding ⟨i, hi1⟩ : (a_1 : Fin (b.blocksFun ⟨i, hi1⟩)) → Fin a.length) ⟨j, hj1⟩)
hk2 :
  k <
    blocksFun (n := (a.gather b).blocksFun ⟨(↑(⟨i, hi1⟩ : Fin b.length) : ℕ), ⋯⟩)
      (a.sigmaCompositionAux b ⟨(↑(⟨i, hi1⟩ : Fin b.length) : ℕ), ⋯⟩)
      ⟨(↑(⟨j, hj1⟩ : Fin (b.blocksFun (⟨i, hi1⟩ : Fin b.length))) : ℕ), ⋯⟩
⊢ (v ∘
        (⇑((Sigma.fst (β := fun (a : Composition n) ↦ Composition a.length)
                  (Sigma.mk (β := fun (a : Composition n) ↦ Composition a.length) a b)).embedding
              ((embedding
                    (Sigma.snd (β := fun (a : Composition n) ↦ Composition a.length)
                      (Sigma.mk (β := fun (a : Composition n) ↦ Composition a.length) a b))
                    (⟨i, hi1⟩ : Fin b.length) :
                  (a_1 : Fin (⟨a, b⟩.snd.blocksFun ⟨i, hi1⟩)) → Fin ⟨a, b⟩.fst.length)
                (⟨j, hj1⟩ : Fin (b.blocksFun (⟨i, hi1⟩ : Fin b.length))))) :
          (a :
              Fin
                (⟨a, b⟩.fst.blocksFun
                  ((⟨a, b⟩.snd.embedding ⟨i, hi1⟩ : (a_1 : Fin (⟨a, b⟩.snd.blocksFun ⟨i, hi1⟩)) → Fin ⟨a, b⟩.fst.length)
                    ⟨j, hj1⟩))) →
            Fin n))
      (⟨k, hk1⟩ :
        Fin
          (a.blocksFun
            ((b.embedding (⟨i, hi1⟩ : Fin b.length) : (a_1 : Fin (b.blocksFun ⟨i, hi1⟩)) → Fin a.length)
              (⟨j, hj1⟩ : Fin (b.blocksFun (⟨i, hi1⟩ : Fin b.length)))))) =
    Function.comp (β :=
      Fin
        ((Sigma.fst (β := fun (c : Composition n) ↦ (i : Fin c.length) → Composition (c.blocksFun i))
              (Sigma.mk (β := fun (c : Composition n) ↦ (i : Fin c.length) → Composition (c.blocksFun i)) (a.gather b)
                (a.sigmaCompositionAux b))).blocksFun
          ⟨i, hi2⟩))
      (v ∘
        (⇑((Sigma.fst (β := fun (c : Composition n) ↦ (i : Fin c.length) → Composition (c.blocksFun i))
                  (Sigma.mk (β := fun (c : Composition n) ↦ (i : Fin c.length) → Composition (c.blocksFun i))
                    (a.gather b) (a.sigmaCompositionAux b))).embedding
              ⟨i, hi2⟩) :
          (a : Fin (⟨a.gather b, a.sigmaCompositionAux b⟩.fst.blocksFun ⟨i, hi2⟩)) → Fin n))
      (⇑(embedding
            (Sigma.snd (β := fun (c : Composition n) ↦ (i : Fin c.length) → Composition (c.blocksFun i))
              (Sigma.mk (β := fun (c : Composition n) ↦ (i : Fin c.length) → Composition (c.blocksFun i)) (a.gather b)
                (a.sigmaCompositionAux b))
              (⟨i, hi2⟩ : Fin (a.gather b).length))
            (⟨j, hj2⟩ :
              Fin
                (Composition.length (n :=
                  (a.gather b).blocksFun (⟨(↑(⟨i, hi1⟩ : Fin b.length) : ℕ), ⋯⟩ : Fin (a.gather b).length))
                  (a.sigmaCompositionAux b (⟨(↑(⟨i, hi1⟩ : Fin b.length) : ℕ), ⋯⟩ : Fin (a.gather b).length))))) :
        (a_1 : Fin ((⟨a.gather b, a.sigmaCompositionAux b⟩.snd ⟨i, hi2⟩).blocksFun ⟨j, hj2⟩)) →
          Fin (⟨a.gather b, a.sigmaCompositionAux b⟩.fst.blocksFun ⟨i, hi2⟩))
      (⟨k, hk2⟩ :
        Fin
          (blocksFun (n := (a.gather b).blocksFun (⟨(↑(⟨i, hi1⟩ : Fin b.length) : ℕ), ⋯⟩ : Fin (a.gather b).length))
            (a.sigmaCompositionAux b (⟨(↑(⟨i, hi1⟩ : Fin b.length) : ℕ), ⋯⟩ : Fin (a.gather b).length))
            (⟨(↑(⟨j, hj1⟩ : Fin (b.blocksFun (⟨i, hi1⟩ : Fin b.length))) : ℕ), ⋯⟩ :
              Fin
                (Composition.length (n :=
                  (a.gather b).blocksFun (⟨(↑(⟨i, hi1⟩ : Fin b.length) : ℕ), ⋯⟩ : Fin (a.gather b).length))
                  (a.sigmaCompositionAux b (⟨(↑(⟨i, hi1⟩ : Fin b.length) : ℕ), ⋯⟩ : Fin (a.gather b).length))))))
have h : (↑(((Sigma.fst (β := fun (a : Composition n) ↦ Composition a.length)
                (Sigma.mk (β := fun (a : Composition n) ↦ Composition a.length) a b)).embedding
            ((embedding
                  (Sigma.snd (β := fun (a : Composition n) ↦ Composition a.length)
                    (Sigma.mk (β := fun (a : Composition n) ↦ Composition a.length) a b))
                  (⟨i, hi1⟩ : Fin b.length) :
                (a_1 : Fin (⟨a, b⟩.snd.blocksFun ⟨i, hi1⟩)) → Fin ⟨a, b⟩.fst.length)
              (⟨j, hj1⟩ : Fin (b.blocksFun (⟨i, hi1⟩ : Fin b.length)))) :
          (a :
              Fin
                (⟨a, b⟩.fst.blocksFun
                  ((⟨a, b⟩.snd.embedding ⟨i, hi1⟩ : (a_1 : Fin (⟨a, b⟩.snd.blocksFun ⟨i, hi1⟩)) → Fin ⟨a, b⟩.fst.length)
                    ⟨j, hj1⟩))) →
            Fin n)
        (⟨k, hk1⟩ :
          Fin
            (a.blocksFun
              ((b.embedding (⟨i, hi1⟩ : Fin b.length) : (a_1 : Fin (b.blocksFun ⟨i, hi1⟩)) → Fin a.length)
                (⟨j, hj1⟩ : Fin (b.blocksFun (⟨i, hi1⟩ : Fin b.length))))))) :
    ℕ) =
  (↑(((Sigma.fst (β := fun (c : Composition n) ↦ (i : Fin c.length) → Composition (c.blocksFun i))
                (Sigma.mk (β := fun (c : Composition n) ↦ (i : Fin c.length) → Composition (c.blocksFun i)) (a.gather b)
                  (a.sigmaCompositionAux b))).embedding
            ⟨i, hi2⟩ :
          (a : Fin (⟨a.gather b, a.sigmaCompositionAux b⟩.fst.blocksFun ⟨i, hi2⟩)) → Fin n)
        ((embedding
              (Sigma.snd (β := fun (c : Composition n) ↦ (i : Fin c.length) → Composition (c.blocksFun i))
                (Sigma.mk (β := fun (c : Composition n) ↦ (i : Fin c.length) → Composition (c.blocksFun i)) (a.gather b)
                  (a.sigmaCompositionAux b))
                (⟨i, hi2⟩ : Fin (a.gather b).length))
              (⟨j, hj2⟩ :
                Fin
                  (Composition.length (n :=
                    (a.gather b).blocksFun (⟨(↑(⟨i, hi1⟩ : Fin b.length) : ℕ), sorry⟩ : Fin (a.gather b).length))
                    (a.sigmaCompositionAux b (⟨(↑(⟨i, hi1⟩ : Fin b.length) : ℕ), sorry⟩ : Fin (a.gather b).length)))) :
            (a_1 : Fin ((⟨a.gather b, a.sigmaCompositionAux b⟩.snd ⟨i, hi2⟩).blocksFun ⟨j, hj2⟩)) →
              Fin (⟨a.gather b, a.sigmaCompositionAux b⟩.fst.blocksFun ⟨i, hi2⟩))
          ⟨k, hk2⟩)) :
    ℕ)
Tactic: refine congr_arg v (Fin.ext ?_)