-- Module: Mathlib.LinearAlgebra.PerfectPairing.Restrict
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)) ⊤
this_1 : IsReflexive L M
this_2 : 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))
b : Basis { x : M // x ∈ v } L M := Basis.mk hv₃ ⋯
this_3 : Fintype (↑v : Type u_3)
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))
bN : Basis { x : N // x ∈ w } L N := 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)
bM : Basis.{u_4, u_2, u_3} { x : N // x ∈ w } L M := 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)))
rw :
  ∀ (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)
⊢ Membership.mem (γ := Submodule K M) (span K v) m

Tactic:
rw [h_span, Basis.mem_span_iff_repr_mem, ← Basis.toMatrix_mulVec_repr bM b m]

Premises used: Module.Basis.toMatrix_mulVec_repr, Module.Basis.mem_span_iff_repr_mem