-- Lean 4 proof step from Mathlib.LinearAlgebra.PerfectPairing.Restrict (goal)
Goal:
K : Type u_1
L : Type u_2
M : Type u_3
N : Type u_4
inst : Field K
inst_1 : Field L
inst_2 : Algebra K L
inst_3 : AddCommGroup M
inst_4 : AddCommGroup N
inst_5 : Module L M
inst_6 : Module L N
inst_7 : Module K M
inst_8 : Module K N
inst_9 : IsScalarTower K L M
p : M →ₗ[L] N →ₗ[L] L
inst_10 : p.IsPerfPair
M' : Submodule K M
N' : Submodule K N
hM : Eq (α := Submodule L M) (span L (↑M' : Set M)) ⊤
hN : Eq (α := Submodule L N) (span L (↑N' : Set N)) ⊤
hp :
  ∀ x ∈ M',
    ∀ y ∈ N',
      Membership.mem.{u_2, u_2} (α := L) (γ := Subring L) (RingHom.range.{u_1, u_2} (R := K) (algebraMap K L))
        ((((p : (a : M) → N →ₗ[L] L) x : N →ₗ[L] L) : (a : N) → L) y : L)
have have₁ have₂ :
  ∀ (this : IsReflexive L M),
    ∃ (n : ℕ) (b : Basis (Fin n) L M) (b' : Basis.{0, u_1, u_3} (Fin n) K ↥M'),
      ∀ (i : Fin n), Eq.{u_3 + 1} (α := M) ((b : (a : Fin n) → M) i : M) ((↑((b' : (a : Fin n) → ↥M') i) : M) : M)
have₃ :
  ∀ (this : IsReflexive L M) (this : IsReflexive L N),
    ∃ (n : ℕ) (b : Basis (Fin n) L M) (b' : Basis.{0, u_1, u_3} (Fin n) K ↥M'),
      ∀ (i : Fin n), Eq.{u_3 + 1} (α := M) ((b : (a : Fin n) → M) i : M) ((↑((b' : (a : Fin n) → ↥M') i) : M) : M)
have₄ :
  ∀ (this : IsReflexive L M) (this : IsReflexive L N) (v : Set M) (hv₁ : v ⊆ (↑M' : Set M))
    (hv₂ : Eq (α := Submodule L M) (span L v) (span L (↑M' : Set M)))
    (hv₃ : LinearIndependent.{u_3, u_2, u_3} (ι := { x : M // x ∈ v }) L (Subtype.val (p := fun (x : M) ↦ x ∈ v))),
    ∃ (n : ℕ) (b : Basis (Fin n) L M) (b' : Basis.{0, u_1, u_3} (Fin n) K ↥M'),
      ∀ (i : Fin n), Eq.{u_3 + 1} (α := M) ((b : (a : Fin n) → M) i : M) ((↑((b' : (a : Fin n) → ↥M') i) : M) : M)
have₅ have₆ :
  ∀ (this : IsReflexive L M) (this : IsReflexive L N) (v : Set M) (hv₁ : v ⊆ (↑M' : Set M))
    (hv₂ : Eq (α := Submodule L M) (span L v) ⊤)
    (hv₃ : LinearIndependent.{u_3, u_2, u_3} (ι := { x : M // x ∈ v }) L (Subtype.val (p := fun (x : M) ↦ x ∈ v))),
    ∃ (n : ℕ) (b : Basis (Fin n) L M) (b' : Basis.{0, u_1, u_3} (Fin n) K ↥M'),
      ∀ (i : Fin n), Eq.{u_3 + 1} (α := M) ((b : (a : Fin n) → M) i : M) ((↑((b' : (a : Fin n) → ↥M') i) : M) : M)
have₇ have₈ :
  ∀ (this : IsReflexive L M) (this : IsReflexive L N) (v : Set M) (hv₁ : v ⊆ (↑M' : Set M))
    (hv₂ : Eq (α := Submodule L M) (span L v) ⊤)
    (hv₃ : LinearIndependent.{u_3, u_2, u_3} (ι := { x : M // x ∈ v }) L (Subtype.val (p := fun (x : M) ↦ x ∈ v)))
    (this : Fintype (↑v : Type u_3)),
    ∃ (n : ℕ) (b : Basis (Fin n) L M) (b' : Basis.{0, u_1, u_3} (Fin n) K ↥M'),
      ∀ (i : Fin n), Eq.{u_3 + 1} (α := M) ((b : (a : Fin n) → M) i : M) ((↑((b' : (a : Fin n) → ↥M') i) : M) : M)
have₉ :
  ∀ (this : IsReflexive L M) (this : IsReflexive L N) (v : Set M) (hv₁ : v ⊆ (↑M' : Set M))
    (hv₂ : Eq (α := Submodule L M) (span L v) ⊤)
    (hv₃ : LinearIndependent.{u_3, u_2, u_3} (ι := { x : M // x ∈ v }) L (Subtype.val (p := fun (x : M) ↦ x ∈ v)))
    (this : Fintype (↑v : Type u_3)),
    let v' : (↑v : Type u_3) → ↥M' := fun (i : (↑v : Type u_3)) ↦ Subtype.mk (p := fun (x : M) ↦ x ∈ M') (↑i : M) ⋯;
    ∀ (hv' : LinearIndependent K v'),
      ∃ (n : ℕ) (b : Basis (Fin n) L M) (b' : Basis.{0, u_1, u_3} (Fin n) K ↥M'),
        ∀ (i : Fin n), Eq.{u_3 + 1} (α := M) ((b : (a : Fin n) → M) i : M) ((↑((b' : (a : Fin n) → ↥M') i) : M) : M)
have₁₀ :
  ∀ (this : IsReflexive L M) (this : IsReflexive L N) (v : Set M) (hv₁ : v ⊆ (↑M' : Set M))
    (hv₂ : Eq (α := Submodule L M) (span L v) ⊤)
    (hv₃ : LinearIndependent.{u_3, u_2, u_3} (ι := { x : M // x ∈ v }) L (Subtype.val (p := fun (x : M) ↦ x ∈ v)))
    (this : Fintype (↑v : Type u_3)),
    let v' : (↑v : Type u_3) → ↥M' := fun (i : (↑v : Type u_3)) ↦ Subtype.mk (p := fun (x : M) ↦ x ∈ M') (↑i : M) ⋯;
    ∀ (hv' : LinearIndependent K v'), Eq (α := Submodule K ↥M') (span K (Set.range v')) ⊤
have₁₁ :
  ∀ (this : IsReflexive L M) (this : IsReflexive L N) (v : Set M) (hv₁ : v ⊆ (↑M' : Set M))
    (hv₂ : Eq (α := Submodule L M) (span L v) ⊤)
    (hv₃ : LinearIndependent.{u_3, u_2, u_3} (ι := { x : M // x ∈ v }) L (Subtype.val (p := fun (x : M) ↦ x ∈ v)))
    (this : Fintype (↑v : Type u_3)),
    let v' : (↑v : Type u_3) → ↥M' := fun (i : (↑v : Type u_3)) ↦ Subtype.mk (p := fun (x : M) ↦ x ∈ M') (↑i : M) ⋯;
    ∀ (hv' : LinearIndependent K v'), span K v = M'
have₁₂ :
  ∀ (this : IsReflexive L M) (this : IsReflexive L N) (v : Set M) (hv₁ : v ⊆ (↑M' : Set M))
    (hv₂ : Eq (α := Submodule L M) (span L v) ⊤)
    (hv₃ : LinearIndependent.{u_3, u_2, u_3} (ι := { x : M // x ∈ v }) L (Subtype.val (p := fun (x : M) ↦ x ∈ v)))
    (this : Fintype (↑v : Type u_3)),
    let v' : (↑v : Type u_3) → ↥M' := fun (i : (↑v : Type u_3)) ↦ Subtype.mk (p := fun (x : M) ↦ x ∈ M') (↑i : M) ⋯;
    ∀ (hv' : LinearIndependent K v') (m : M) (hm : m ∈ M'), Membership.mem (γ := Submodule K M) (span K v) m
have₁₃ :
  ∀ (this : IsReflexive L M) (this : IsReflexive L N) (v : Set M) (hv₁ : v ⊆ (↑M' : Set M))
    (hv₂ : Eq (α := Submodule L M) (span L v) ⊤)
    (hv₃ : LinearIndependent.{u_3, u_2, u_3} (ι := { x : M // x ∈ v }) L (Subtype.val (p := fun (x : M) ↦ x ∈ v)))
    (this : Fintype (↑v : Type u_3)),
    let v' : (↑v : Type u_3) → ↥M' := fun (i : (↑v : Type u_3)) ↦ Subtype.mk (p := fun (x : M) ↦ x ∈ M') (↑i : M) ⋯;
    ∀ (hv' : LinearIndependent K v') (m : M) (hm : m ∈ M') (w : Set N) (hw₁ : w ⊆ (↑N' : Set N))
      (hw₂ : Eq (α := Submodule L N) (span L w) (span L (↑N' : Set N)))
      (hw₃ : LinearIndependent.{u_4, u_2, u_4} (ι := { x : N // x ∈ w }) L (Subtype.val (p := fun (x : N) ↦ x ∈ w))),
      Membership.mem (γ := Submodule K M) (span K v) m
have₁₄ :
  ∀ (this : IsReflexive L M) (this : IsReflexive L N) (v : Set M) (hv₁ : v ⊆ (↑M' : Set M))
    (hv₂ : Eq (α := Submodule L M) (span L v) ⊤)
    (hv₃ : LinearIndependent.{u_3, u_2, u_3} (ι := { x : M // x ∈ v }) L (Subtype.val (p := fun (x : M) ↦ x ∈ v)))
    (this : Fintype (↑v : Type u_3)),
    let v' : (↑v : Type u_3) → ↥M' := fun (i : (↑v : Type u_3)) ↦ Subtype.mk (p := fun (x : M) ↦ x ∈ M') (↑i : M) ⋯;
    ∀ (hv' : LinearIndependent K v') (m : M) (hm : m ∈ M') (w : Set N) (hw₁ : w ⊆ (↑N' : Set N))
      (hw₂ : Eq (α := Submodule L N) (span L w) ⊤)
      (hw₃ : LinearIndependent.{u_4, u_2, u_4} (ι := { x : N // x ∈ w }) L (Subtype.val (p := fun (x : N) ↦ x ∈ w))),
      Membership.mem (γ := Submodule K M) (span K v) m
have₁₅ :
  ∀ (this : IsReflexive L M) (this : IsReflexive L N) (v : Set M) (hv₁ : v ⊆ (↑M' : Set M))
    (hv₂ : Eq (α := Submodule L M) (span L v) ⊤)
    (hv₃ : LinearIndependent.{u_3, u_2, u_3} (ι := { x : M // x ∈ v }) L (Subtype.val (p := fun (x : M) ↦ x ∈ v)))
    (this : Fintype (↑v : Type u_3)),
    let v' : (↑v : Type u_3) → ↥M' := fun (i : (↑v : Type u_3)) ↦ Subtype.mk (p := fun (x : M) ↦ x ∈ M') (↑i : M) ⋯;
    ∀ (hv' : LinearIndependent K v') (m : M) (hm : m ∈ M') (w : Set N) (hw₁ : w ⊆ (↑N' : Set N))
      (hw₂ : Eq (α := Submodule L N) (span L w) ⊤)
      (hw₃ : LinearIndependent.{u_4, u_2, u_4} (ι := { x : N // x ∈ w }) L (Subtype.val (p := fun (x : N) ↦ x ∈ w))),
      Membership.mem (γ := Submodule K M) (span K v) m
have₁₆ :
  ∀ (this : IsReflexive L M) (this : IsReflexive L N) (v : Set M) (hv₁ : v ⊆ (↑M' : Set M))
    (hv₂ : Eq (α := Submodule L M) (span L v) ⊤)
    (hv₃ : LinearIndependent.{u_3, u_2, u_3} (ι := { x : M // x ∈ v }) L (Subtype.val (p := fun (x : M) ↦ x ∈ v)))
    (this : Fintype (↑v : Type u_3)),
    let v' : (↑v : Type u_3) → ↥M' := fun (i : (↑v : Type u_3)) ↦ Subtype.mk (p := fun (x : M) ↦ x ∈ M') (↑i : M) ⋯;
    ∀ (hv' : LinearIndependent K v') (m : M) (hm : m ∈ M') (w : Set N) (hw₁ : w ⊆ (↑N' : Set N))
      (hw₂ : Eq (α := Submodule L N) (span L w) ⊤)
      (hw₃ : LinearIndependent.{u_4, u_2, u_4} (ι := { x : N // x ∈ w }) L (Subtype.val (p := fun (x : N) ↦ x ∈ w)))
      (this : Fintype (↑w : Type u_4)), Membership.mem (γ := Submodule K M) (span K v) m
have₁₇ have₁₈ :
  ∀ (this : IsReflexive L M) (this : IsReflexive L N) (v : Set M) (hv₁ : v ⊆ (↑M' : Set M))
    (hv₂ : Eq (α := Submodule L M) (span L v) ⊤)
    (hv₃ : LinearIndependent.{u_3, u_2, u_3} (ι := { x : M // x ∈ v }) L (Subtype.val (p := fun (x : M) ↦ x ∈ v)))
    (this : Fintype (↑v : Type u_3)),
    let v' : (↑v : Type u_3) → ↥M' := fun (i : (↑v : Type u_3)) ↦ Subtype.mk (p := fun (x : M) ↦ x ∈ M') (↑i : M) ⋯;
    ∀ (hv' : LinearIndependent K v') (m : M) (hm : m ∈ M') (w : Set N) (hw₁ : w ⊆ (↑N' : Set N))
      (hw₂ : Eq (α := Submodule L N) (span L w) ⊤)
      (hw₃ : LinearIndependent.{u_4, u_2, u_4} (ι := { x : N // x ∈ w }) L (Subtype.val (p := fun (x : N) ↦ x ∈ w)))
      (this : Fintype (↑w : Type u_4)) (e : Equiv.{u_3 + 1, u_4 + 1} (↑v : Type u_3) (↑w : Type u_4)),
      Membership.mem (γ := Submodule K M) (span K v) m
have₁₉ :
  ∀ (this : IsReflexive L M) (this : IsReflexive L N) (v : Set M) (hv₁ : v ⊆ (↑M' : Set M))
    (hv₂ : Eq (α := Submodule L M) (span L v) ⊤)
    (hv₃ : LinearIndependent.{u_3, u_2, u_3} (ι := { x : M // x ∈ v }) L (Subtype.val (p := fun (x : M) ↦ x ∈ v)))
    (this : Fintype (↑v : Type u_3)),
    let v' : (↑v : Type u_3) → ↥M' := fun (i : (↑v : Type u_3)) ↦ Subtype.mk (p := fun (x : M) ↦ x ∈ M') (↑i : M) ⋯;
    ∀ (hv' : LinearIndependent K v') (m : M) (hm : m ∈ M') (w : Set N) (hw₁ : w ⊆ (↑N' : Set N))
      (hw₂ : Eq (α := Submodule L N) (span L w) ⊤)
      (hw₃ : LinearIndependent.{u_4, u_2, u_4} (ι := { x : N // x ∈ w }) L (Subtype.val (p := fun (x : N) ↦ x ∈ w))),
      let bN := Basis.mk hw₃ ⋯;
      ∀ (this : Fintype (↑w : Type u_4)) (e : Equiv.{u_3 + 1, u_4 + 1} (↑v : Type u_3) (↑w : Type u_4)),
        let bM := bN.dualBasis.map p.toPerfPair.symm;
        ∀
          (hbM :
            ∀ (j : (↑w : Type u_4)) (x : M) (hx : x ∈ M'),
              Eq.{u_2 + 1} (α := L)
                ((((bM.repr : (a : M) → { x : N // x ∈ w } →₀ L) x : Finsupp.{u_4, u_2} { x : N // x ∈ w } L) :
                      (a : { x : N // x ∈ w }) → L)
                    j :
                  L)
                ((((p : (a : M) → N →ₗ[L] L) x : N →ₗ[L] L) : (a : N) → L) (↑j : N) : L)),
          Membership.mem (γ := Submodule K M) (span K v) m
have₂₀ :
  ∀ (this : IsReflexive L M) (this : IsReflexive L N) (v : Set M) (hv₁ : v ⊆ (↑M' : Set M))
    (hv₂ : Eq (α := Submodule L M) (span L v) ⊤)
    (hv₃ : LinearIndependent.{u_3, u_2, u_3} (ι := { x : M // x ∈ v }) L (Subtype.val (p := fun (x : M) ↦ x ∈ v)))
    (this : Fintype (↑v : Type u_3)),
    let v' : (↑v : Type u_3) → ↥M' := fun (i : (↑v : Type u_3)) ↦ Subtype.mk (p := fun (x : M) ↦ x ∈ M') (↑i : M) ⋯;
    ∀ (hv' : LinearIndependent K v') (m : M) (hm : m ∈ M') (w : Set N) (hw₁ : w ⊆ (↑N' : Set N))
      (hw₂ : Eq (α := Submodule L N) (span L w) ⊤)
      (hw₃ : LinearIndependent.{u_4, u_2, u_4} (ι := { x : N // x ∈ w }) L (Subtype.val (p := fun (x : N) ↦ x ∈ w))),
      let bN := Basis.mk hw₃ ⋯;
      ∀ (this : Fintype (↑w : Type u_4)) (e : Equiv.{u_3 + 1, u_4 + 1} (↑v : Type u_3) (↑w : Type u_4)),
        let bM := bN.dualBasis.map p.toPerfPair.symm;
        ∀
          (hbM :
            ∀ (j : (↑w : Type u_4)) (x : M) (hx : x ∈ M'),
              Eq.{u_2 + 1} (α := L)
                ((((bM.repr : (a : M) → { x : N // x ∈ w } →₀ L) x : Finsupp.{u_4, u_2} { x : N // x ∈ w } L) :
                      (a : { x : N // x ∈ w }) → L)
                    j :
                  L)
                ((((p : (a : M) → N →ₗ[L] L) x : N →ₗ[L] L) : (a : N) → L) (↑j : N) : L))
          (hj :
            ∀ (j : (↑w : Type u_4)),
              Membership.mem.{u_2, u_2} (α := L) (γ := Subring L) (RingHom.range.{u_1, u_2} (R := K) (algebraMap K L))
                ((((bM.repr : (a : M) → { x : N // x ∈ w } →₀ L) m : Finsupp.{u_4, u_2} { x : N // x ∈ w } L) :
                      (a : { x : N // x ∈ w }) → L)
                    j :
                  L)),
          Membership.mem (γ := Submodule K M) (span K v) m
have₂₁ :
  ∀ (this : IsReflexive L M) (this : IsReflexive L N) (v : Set M) (hv₁ : v ⊆ (↑M' : Set M))
    (hv₂ : Eq (α := Submodule L M) (span L v) ⊤)
    (hv₃ : LinearIndependent.{u_3, u_2, u_3} (ι := { x : M // x ∈ v }) L (Subtype.val (p := fun (x : M) ↦ x ∈ v))),
    let b := Basis.mk hv₃ ⋯;
    ∀ (this : Fintype (↑v : Type u_3)),
      let v' : (↑v : Type u_3) → ↥M' := fun (i : (↑v : Type u_3)) ↦ Subtype.mk (p := fun (x : M) ↦ x ∈ M') (↑i : M) ⋯;
      ∀ (hv' : LinearIndependent K v') (m : M) (hm : m ∈ M') (w : Set N) (hw₁ : w ⊆ (↑N' : Set N))
        (hw₂ : Eq (α := Submodule L N) (span L w) ⊤)
        (hw₃ : LinearIndependent.{u_4, u_2, u_4} (ι := { x : N // x ∈ w }) L (Subtype.val (p := fun (x : N) ↦ x ∈ w))),
        let bN := Basis.mk hw₃ ⋯;
        ∀ (this : Fintype (↑w : Type u_4)) (e : Equiv.{u_3 + 1, u_4 + 1} (↑v : Type u_3) (↑w : Type u_4)),
          let bM := bN.dualBasis.map p.toPerfPair.symm;
          ∀
            (hbM :
              ∀ (j : (↑w : Type u_4)) (x : M) (hx : x ∈ M'),
                Eq.{u_2 + 1} (α := L)
                  ((((bM.repr : (a : M) → { x : N // x ∈ w } →₀ L) x : Finsupp.{u_4, u_2} { x : N // x ∈ w } L) :
                        (a : { x : N // x ∈ w }) → L)
                      j :
                    L)
                  ((((p : (a : M) → N →ₗ[L] L) x : N →ₗ[L] L) : (a : N) → L) (↑j : N) : L))
            (hj :
              ∀ (j : (↑w : Type u_4)),
                Membership.mem.{u_2, u_2} (α := L) (γ := Subring L) (RingHom.range.{u_1, u_2} (R := K) (algebraMap K L))
                  ((((bM.repr : (a : M) → { x : N // x ∈ w } →₀ L) m : Finsupp.{u_4, u_2} { x : N // x ∈ w } L) :
                        (a : { x : N // x ∈ w }) → L)
                      j :
                    L))
            (hp :
              ∀ (i : (↑w : Type u_4)) (j : (↑v : Type u_3)),
                Membership.mem (γ := Subfield L) (RingHom.fieldRange.{u_1, u_2} (K := K) (algebraMap K L))
                  ((bN.dualBasis.map p.toPerfPair.symm).toMatrix (⇑b : (a : { x : M // x ∈ v }) → M) i j)),
            Membership.mem (γ := Submodule K M) (span K v) m
have₂₂ :
  ∀ (this : IsReflexive L M) (this : IsReflexive L N) (v : Set M) (hv₁ : v ⊆ (↑M' : Set M))
    (hv₂ : Eq (α := Submodule L M) (span L v) ⊤)
    (hv₃ : LinearIndependent.{u_3, u_2, u_3} (ι := { x : M // x ∈ v }) L (Subtype.val (p := fun (x : M) ↦ x ∈ v))),
    let b := Basis.mk hv₃ ⋯;
    ∀ (this : Fintype (↑v : Type u_3)),
      let v' : (↑v : Type u_3) → ↥M' := fun (i : (↑v : Type u_3)) ↦ Subtype.mk (p := fun (x : M) ↦ x ∈ M') (↑i : M) ⋯;
      ∀ (hv' : LinearIndependent K v') (m : M) (hm : m ∈ M') (w : Set N) (hw₁ : w ⊆ (↑N' : Set N))
        (hw₂ : Eq (α := Submodule L N) (span L w) ⊤)
        (hw₃ : LinearIndependent.{u_4, u_2, u_4} (ι := { x : N // x ∈ w }) L (Subtype.val (p := fun (x : N) ↦ x ∈ w))),
        let bN := Basis.mk hw₃ ⋯;
        ∀ (this : Fintype (↑w : Type u_4)) (e : Equiv.{u_3 + 1, u_4 + 1} (↑v : Type u_3) (↑w : Type u_4)),
          let bM := bN.dualBasis.map p.toPerfPair.symm;
          ∀
            (hbM :
              ∀ (j : (↑w : Type u_4)) (x : M) (hx : x ∈ M'),
                Eq.{u_2 + 1} (α := L)
                  ((((bM.repr : (a : M) → { x : N // x ∈ w } →₀ L) x : Finsupp.{u_4, u_2} { x : N // x ∈ w } L) :
                        (a : { x : N // x ∈ w }) → L)
                      j :
                    L)
                  ((((p : (a : M) → N →ₗ[L] L) x : N →ₗ[L] L) : (a : N) → L) (↑j : N) : L))
            (hj :
              ∀ (j : (↑w : Type u_4)),
                Membership.mem.{u_2, u_2} (α := L) (γ := Subring L) (RingHom.range.{u_1, u_2} (R := K) (algebraMap K L))
                  ((((bM.repr : (a : M) → { x : N // x ∈ w } →₀ L) m : Finsupp.{u_4, u_2} { x : N // x ∈ w } L) :
                        (a : { x : N // x ∈ w }) → L)
                      j :
                    L))
            (hp :
              ∀ (i : (↑w : Type u_4)) (j : (↑v : Type u_3)),
                Membership.mem (γ := Subfield L) (RingHom.fieldRange.{u_1, u_2} (K := K) (algebraMap K L))
                  ((bN.dualBasis.map p.toPerfPair.symm).toMatrix (⇑b : (a : { x : M // x ∈ v }) → M) i j))
            (hA :
              ∀ (i : { x : M // x ∈ v }) (j : { x : N // x ∈ w }),
                Membership.mem (γ := Subring L) (RingHom.range.{u_1, u_2} (R := K) (algebraMap K L))
                  (b.toMatrix (⇑bM : (a : { x : N // x ∈ w }) → M) i j)),
            Membership.mem (γ := Submodule K M) (span K v) m
have₂₃ :
  ∀ (this : IsReflexive L M) (this : IsReflexive L N) (v : Set M) (hv₁ : v ⊆ (↑M' : Set M))
    (hv₂ : Eq (α := Submodule L M) (span L v) ⊤)
    (hv₃ : LinearIndependent.{u_3, u_2, u_3} (ι := { x : M // x ∈ v }) L (Subtype.val (p := fun (x : M) ↦ x ∈ v))),
    let b := Basis.mk hv₃ ⋯;
    ∀ (this : Fintype (↑v : Type u_3)),
      let v' : (↑v : Type u_3) → ↥M' := fun (i : (↑v : Type u_3)) ↦ Subtype.mk (p := fun (x : M) ↦ x ∈ M') (↑i : M) ⋯;
      ∀ (hv' : LinearIndependent K v') (m : M) (hm : m ∈ M') (w : Set N) (hw₁ : w ⊆ (↑N' : Set N))
        (hw₂ : Eq (α := Submodule L N) (span L w) ⊤)
        (hw₃ : LinearIndependent.{u_4, u_2, u_4} (ι := { x : N // x ∈ w }) L (Subtype.val (p := fun (x : N) ↦ x ∈ w))),
        let bN := Basis.mk hw₃ ⋯;
        ∀ (this : Fintype (↑w : Type u_4)) (e : Equiv.{u_3 + 1, u_4 + 1} (↑v : Type u_3) (↑w : Type u_4)),
          let bM := bN.dualBasis.map p.toPerfPair.symm;
          ∀
            (hbM :
              ∀ (j : (↑w : Type u_4)) (x : M) (hx : x ∈ M'),
                Eq.{u_2 + 1} (α := L)
                  ((((bM.repr : (a : M) → { x : N // x ∈ w } →₀ L) x : Finsupp.{u_4, u_2} { x : N // x ∈ w } L) :
                        (a : { x : N // x ∈ w }) → L)
                      j :
                    L)
                  ((((p : (a : M) → N →ₗ[L] L) x : N →ₗ[L] L) : (a : N) → L) (↑j : N) : L))
            (hj :
              ∀ (j : (↑w : Type u_4)),
                Membership.mem.{u_2, u_2} (α := L) (γ := Subring L) (RingHom.range.{u_1, u_2} (R := K) (algebraMap K L))
                  ((((bM.repr : (a : M) → { x : N // x ∈ w } →₀ L) m : Finsupp.{u_4, u_2} { x : N // x ∈ w } L) :
                        (a : { x : N // x ∈ w }) → L)
                      j :
                    L))
            (hp :
              ∀ (i : (↑w : Type u_4)) (j : (↑v : Type u_3)),
                Membership.mem (γ := Subfield L) (RingHom.fieldRange.{u_1, u_2} (K := K) (algebraMap K L))
                  ((bN.dualBasis.map p.toPerfPair.symm).toMatrix (⇑b : (a : { x : M // x ∈ v }) → M) i j))
            (hA :
              ∀ (i : { x : M // x ∈ v }) (j : { x : N // x ∈ w }),
                Membership.mem (γ := Subring L) (RingHom.range.{u_1, u_2} (R := K) (algebraMap K L))
                  (b.toMatrix (⇑bM : (a : { x : N // x ∈ w }) → M) i j))
            (h_span :
              Eq (α := Submodule K M) (span K v)
                (span K (Set.range (ι := { x : M // x ∈ v }) (⇑b : (a : { x : M // x ∈ v }) → M)))),
            Membership.mem (γ := Submodule K M) (span K v) m
⊢ ∃ (n : ℕ) (b : Basis (Fin n) L M) (b' : Basis.{0, u_1, u_3} (Fin n) K ↥M'),
    ∀ (i : Fin n), Eq.{u_3 + 1} (α := M) ((b : (a : Fin n) → M) i : M) ((↑((b' : (a : Fin n) → ↥M') i) : M) : M)
have have₂₄ : ∀ (this : IsReflexive L M) (this : IsReflexive L N) (v : Set M) (hv₁ : v ⊆ (↑M' : Set M))
  (hv₂ : Eq (α := Submodule L M) (span L v) ⊤)
  (hv₃ : LinearIndependent.{u_3, u_2, u_3} (ι := { x : M // x ∈ v }) L (Subtype.val (p := fun (x : M) ↦ x ∈ v))),
  let b := Basis.mk hv₃ sorry;
  ∀ (this : Fintype (↑v : Type u_3)),
    let v' : (↑v : Type u_3) → ↥M' := fun (i : (↑v : Type u_3)) ↦ Subtype.mk (p := fun (x : M) ↦ x ∈ M') (↑i : M) sorry;
    ∀ (hv' : LinearIndependent K v') (m : M) (hm : m ∈ M') (w : Set N) (hw₁ : w ⊆ (↑N' : Set N))
      (hw₂ : Eq (α := Submodule L N) (span L w) ⊤)
      (hw₃ : LinearIndependent.{u_4, u_2, u_4} (ι := { x : N // x ∈ w }) L (Subtype.val (p := fun (x : N) ↦ x ∈ w))),
      let bN := Basis.mk hw₃ sorry;
      ∀ (this : Fintype (↑w : Type u_4)) (e : Equiv.{u_3 + 1, u_4 + 1} (↑v : Type u_3) (↑w : Type u_4)),
        let bM := bN.dualBasis.map p.toPerfPair.symm;
        ∀
          (hbM :
            ∀ (j : (↑w : Type u_4)) (x : M) (hx : x ∈ M'),
              Eq.{u_2 + 1} (α := L)
                ((((bM.repr : (a : M) → { x : N // x ∈ w } →₀ L) x : Finsupp.{u_4, u_2} { x : N // x ∈ w } L) :
                      (a : { x : N // x ∈ w }) → L)
                    j :
                  L)
                ((((p : (a : M) → N →ₗ[L] L) x : N →ₗ[L] L) : (a : N) → L) (↑j : N) : L))
          (hj :
            ∀ (j : (↑w : Type u_4)),
              Membership.mem.{u_2, u_2} (α := L) (γ := Subring L) (RingHom.range.{u_1, u_2} (R := K) (algebraMap K L))
                ((((bM.repr : (a : M) → { x : N // x ∈ w } →₀ L) m : Finsupp.{u_4, u_2} { x : N // x ∈ w } L) :
                      (a : { x : N // x ∈ w }) → L)
                    j :
                  L))
          (hp :
            ∀ (i : (↑w : Type u_4)) (j : (↑v : Type u_3)),
              Membership.mem (γ := Subfield L) (RingHom.fieldRange.{u_1, u_2} (K := K) (algebraMap K L))
                ((bN.dualBasis.map p.toPerfPair.symm).toMatrix (⇑b : (a : { x : M // x ∈ v }) → M) i j))
          (hA :
            ∀ (i : { x : M // x ∈ v }) (j : { x : N // x ∈ w }),
              Membership.mem (γ := Subring L) (RingHom.range.{u_1, u_2} (R := K) (algebraMap K L))
                (b.toMatrix (⇑bM : (a : { x : N // x ∈ w }) → M) i j))
          (h_span :
            Eq (α := Submodule K M) (span K v)
              (span K (Set.range (ι := { x : M // x ∈ v }) (⇑b : (a : { x : M // x ∈ v }) → M))))
          (i : { x : M // x ∈ v }),
          Membership.mem (γ := Set L) (Set.range.{u_2, u_1 + 1} (ι := K) (⇑(algebraMap K L) : (a : K) → L))
            (Matrix.mulVec.{u_2, u_3, u_4} (n := { x : N // x ∈ w }) (b.toMatrix (⇑bM : (a : { x : N // x ∈ w }) → M))
              (⇑((bM.repr : (a : M) → { x : N // x ∈ w } →₀ L) m : Finsupp.{u_4, u_2} { x : N // x ∈ w } L) :
                (a : { x : N // x ∈ w }) → L)
              i)
Tactic: classical
  have : IsReflexive L M := .of_isPerfPair p
  have : IsReflexive L N := .of_isPerfPair p.flip
  obtain ⟨v, hv₁, hv₂, hv₃⟩ := exists_linearIndependent L (M' : Set M)
  rw [hM] at hv₂
  let b : Basis _ L M := Basis.mk hv₃ <| by rw [← hv₂, Subtype.range_coe_subtype, Set.setOf_mem_eq]
  have : Fintype v := Set.Finite.fintype <| Module.Finite.finite_basis b
  set v' : v → M' := fun i ↦ ⟨i, hv₁ (Subtype.coe_prop i)⟩
  have hv' : LinearIndependent K v' := by
    replace hv₃ := hv₃.restrict_scalars (R := K) <| by
      simp_rw [← Algebra.algebraMap_eq_smul_one]
      exact FaithfulSMul.algebraMap_injective K L
    rw [show ((↑) : v → M) = M'.subtype ∘ v' by ext; simp [v']] at hv₃
    exact hv₃.of_comp
  suffices span K (Set.range v') = ⊤ by
    let e := (Module.Finite.finite_basis b).equivFin
    let b' : Basis _ K M' := Basis.mk hv' (by rw [this])
    exact ⟨_, b.reindex e, b'.reindex e, fun i ↦ by simp [b, b', v']⟩
  suffices span K v = M' by
    apply Submodule.map_injective_of_injective M'.injective_subtype
    rw [Submodule.map_span, ← Set.image_univ, Set.image_image]
    simpa [v']
  refine le_antisymm (Submodule.span_le.mpr hv₁) fun m hm ↦ ?_
  obtain ⟨w, hw₁, hw₂, hw₃⟩ := exists_linearIndependent L (N' : Set N)
  rw [hN] at hw₂
  let bN : Basis _ L N := Basis.mk hw₃ <| by rw [← hw₂, Subtype.range_coe_subtype, Set.setOf_mem_eq]
  have : Fintype w := Set.Finite.fintype <| Module.Finite.finite_basis bN
  have e : v ≃ w := Fintype.equivOfCardEq <| by rw [← Module.finrank_eq_card_basis b,
    ← Module.finrank_eq_card_basis bN, Module.finrank_of_isPerfPair p]
  let bM := bN.dualBasis.map p.toPerfPair.symm
  have hbM (j : w) (x : M) (hx : x ∈ M') : bM.repr x j = p x (j : N) := by simp [bM, bN]
  have hj (j : w) : bM.repr m j ∈ (algebraMap K L).range := (hbM _ _ hm) ▸ hp m hm j (hw₁ j.2)
  replace hp (i : w) (j : v) :
      (bN.dualBasis.map p.toPerfPair.symm).toMatrix b i j ∈ (algebraMap K L).fieldRange := by
    simp only [Basis.toMatrix, Basis.map_repr, LinearEquiv.symm_symm, LinearEquiv.trans_apply,
      Basis.dualBasis_repr]
    exact hp (b j) (by simpa [b] using hv₁ j.2) (bN i) (by simpa [bN] using hw₁ i.2)
  have hA (i j) : b.toMatrix bM i j ∈ (algebraMap K L).range :=
    Matrix.mem_subfield_of_mul_eq_one_of_mem_subfield_left e _ (by simp [bM]) hp i j
  have h_span : span K v = span K (Set.range b) := by simp [b]
  rw [h_span, Basis.mem_span_iff_repr_mem, ← Basis.toMatrix_mulVec_repr bM b m]
  exact fun i ↦ Subring.sum_mem _ fun j _ ↦ Subring.mul_mem _ (hA i j) (hj j)
Cleared hypotheses: hp