theorem blocksFun_sigmaCompositionAux (a : Composition n) (b : Composition a.length)
    (i : Fin b.length) (j : Fin (blocksFun b i)) :
    blocksFun (sigmaCompositionAux a b ⟨i, (length_gather a b).symm ▸ i.2⟩)
        ⟨j, (length_sigmaCompositionAux a b i).symm ▸ j.2⟩ =
      blocksFun a (embedding b i j) :=
  show get (get _ ⟨_, _⟩) ⟨_, _⟩  = a.blocks.get ⟨_, _⟩ by
    rw [get_of_eq (get_splitWrtComposition _ _ _), get_drop', get_take']; 

Proof state:
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
n : ℕ
a : Composition n
b : Composition (length a)
i : Fin (length b)
j : Fin (blocksFun b i)
⊢ List.get a.blocks
      {
        val :=
          ↑{
              val :=
                sizeUpTo b
                    ↑{ val := ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) },
                        isLt :=
                          (_ :
                            ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) } <
                              List.length (splitWrtComposition a.blocks b)) } +
                  ↑{
                      val :=
                        ↑{ val := ↑j,
                            isLt :=
                              (_ :
                                ↑j <
                                  length
                                    (sigmaCompositionAux a b { val := ↑i, isLt := (_ : ↑i < length (gather a b)) })) },
                      isLt :=
                        (_ :
                          ↑{ val := ↑j,
                                isLt :=
                                  (_ :
                                    ↑j <
                                      length
                                        (sigmaCompositionAux a b
                                          { val := ↑i, isLt := (_ : ↑i < length (gather a b)) })) } <
                            List.length
                              (drop
                                (sizeUpTo b
                                  ↑{ val := ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) },
                                      isLt :=
                                        (_ :
                                          ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) } <
                                            List.length (splitWrtComposition a.blocks b)) })
                                (take
                                  (sizeUpTo b
                                    (↑{ val := ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) },
                                          isLt :=
                                            (_ :
                                              ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) } <
                                                List.length (splitWrtComposition a.blocks b)) } +
                                      1))
                                  a.blocks))) },
              isLt :=
                (_ :
                  sizeUpTo b
                        ↑{ val := ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) },
                            isLt :=
                              (_ :
                                ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) } <
                                  List.length (splitWrtComposition a.blocks b)) } +
                      ↑{
                          val :=
                            ↑{ val := ↑j,
                                isLt :=
                                  (_ :
                                    ↑j <
                                      length
                                        (sigmaCompositionAux a b
                                          { val := ↑i, isLt := (_ : ↑i < length (gather a b)) })) },
                          isLt :=
                            (_ :
                              ↑{ val := ↑j,
                                    isLt :=
                                      (_ :
                                        ↑j <
                                          length
                                            (sigmaCompositionAux a b
                                              { val := ↑i, isLt := (_ : ↑i < length (gather a b)) })) } <
                                List.length
                                  (drop
                                    (sizeUpTo b
                                      ↑{ val := ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) },
                                          isLt :=
                                            (_ :
                                              ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) } <
                                                List.length (splitWrtComposition a.blocks b)) })
                                    (take
                                      (sizeUpTo b
                                        (↑{ val := ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) },
                                              isLt :=
                                                (_ :
                                                  ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) } <
                                                    List.length (splitWrtComposition a.blocks b)) } +
                                          1))
                                      a.blocks))) } <
                    List.length
                      (take
                        (sizeUpTo b
                          (↑{ val := ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) },
                                isLt :=
                                  (_ :
                                    ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) } <
                                      List.length (splitWrtComposition a.blocks b)) } +
                            1))
                        a.blocks)) },
        isLt :=
          (_ :
            ↑{
                  val :=
                    sizeUpTo b
                        ↑{ val := ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) },
                            isLt :=
                              (_ :
                                ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) } <
                                  List.length (splitWrtComposition a.blocks b)) } +
                      ↑{
                          val :=
                            ↑{ val := ↑j,
                                isLt :=
                                  (_ :
                                    ↑j <
                                      length
                                        (sigmaCompositionAux a b
                                          { val := ↑i, isLt := (_ : ↑i < length (gather a b)) })) },
                          isLt :=
                            (_ :
                              ↑{ val := ↑j,
                                    isLt :=
                                      (_ :
                                        ↑j <
                                          length
                                            (sigmaCompositionAux a b
                                              { val := ↑i, isLt := (_ : ↑i < length (gather a b)) })) } <
                                List.length
                                  (drop
                                    (sizeUpTo b
                                      ↑{ val := ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) },
                                          isLt :=
                                            (_ :
                                              ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) } <
                                                List.length (splitWrtComposition a.blocks b)) })
                                    (take
                                      (sizeUpTo b
                                        (↑{ val := ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) },
                                              isLt :=
                                                (_ :
                                                  ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) } <
                                                    List.length (splitWrtComposition a.blocks b)) } +
                                          1))
                                      a.blocks))) },
                  isLt :=
                    (_ :
                      sizeUpTo b
                            ↑{ val := ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) },
                                isLt :=
                                  (_ :
                                    ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) } <
                                      List.length (splitWrtComposition a.blocks b)) } +
                          ↑{
                              val :=
                                ↑{ val := ↑j,
                                    isLt :=
                                      (_ :
                                        ↑j <
                                          length
                                            (sigmaCompositionAux a b
                                              { val := ↑i, isLt := (_ : ↑i < length (gather a b)) })) },
                              isLt :=
                                (_ :
                                  ↑{ val := ↑j,
                                        isLt :=
                                          (_ :
                                            ↑j <
                                              length
                                                (sigmaCompositionAux a b
                                                  { val := ↑i, isLt := (_ : ↑i < length (gather a b)) })) } <
                                    List.length
                                      (drop
                                        (sizeUpTo b
                                          ↑{ val := ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) },
                                              isLt :=
                                                (_ :
                                                  ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) } <
                                                    List.length (splitWrtComposition a.blocks b)) })
                                        (take
                                          (sizeUpTo b
                                            (↑{ val := ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) },
                                                  isLt :=
                                                    (_ :
                                                      ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) } <
                                                        List.length (splitWrtComposition a.blocks b)) } +
                                              1))
                                          a.blocks))) } <
                        List.length
                          (take
                            (sizeUpTo b
                              (↑{ val := ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) },
                                    isLt :=
                                      (_ :
                                        ↑{ val := ↑i, isLt := (_ : ↑i < length (gather a b)) } <
                                          List.length (splitWrtComposition a.blocks b)) } +
                                1))
                            a.blocks)) } <
              List.length a.blocks) } =
    List.get a.blocks
      { val := ↑((Fin.natAddEmb (sizeUpTo b ↑i)).toEmbedding j),
        isLt := (_ : ↑((Fin.natAddEmb (sizeUpTo b ↑i)).toEmbedding j) < length a) }

Next tactic:
rfl