-- Lean 4 proof step from Mathlib.RingTheory.Unramified.Finite (goal)
Goal:
R : Type u_1
S : Type u_2
inst : CommRing R
inst_1 : CommRing S
inst_2 : Algebra R S
inst_3 : FormallyUnramified R S
inst_4 : EssFiniteType R S
inst_5 : Free R S
let let₁ let₂ let₃ : Module.Finite R S
let₄ :
  let I := Free.ChooseBasisIndex R S;
  let b : Basis I R S := Free.chooseBasis R S;
  ∀ (f : I →₀ S) (hf : Eq (α := S ⊗[R] S) (elem R S) (f.sum fun (i : I) (x : S) ↦ x ⊗ₜ[R] (b : (a : I) → S) i)),
    Module.Finite R S
fg_top :
  let I := Free.ChooseBasisIndex R S;
  let b : Basis I R S := Free.chooseBasis R S;
  ∀ (f : I →₀ S) (hf : Eq (α := S ⊗[R] S) (elem R S) (f.sum fun (i : I) (x : S) ↦ x ⊗ₜ[R] (b : (a : I) → S) i)),
    Submodule.FG.{u_1, u_2} (R := R) (M := S) ⊤
h :
  let I := Free.ChooseBasisIndex R S;
  let b : Basis I R S := Free.chooseBasis R S;
  ∀ (f : I →₀ S) (hf : Eq (α := S ⊗[R] S) (elem R S) (f.sum fun (i : I) (x : S) ↦ x ⊗ₜ[R] (b : (a : I) → S) i)),
    Eq (α := Submodule R S)
      (Submodule.span R
        (↑(Finset.image₂
              (fun (i j : I) ↦ HMul.hMul (α := S) (β := S) ((f : (a : I) → S) i : S) ((b : (a : I) → S) j : S))
              f.support f.support) :
          Set S))
      ⊤
h₁ :
  let I := Free.ChooseBasisIndex R S;
  let b : Basis I R S := Free.chooseBasis R S;
  ∀ (f : I →₀ S) (hf : Eq (α := S ⊗[R] S) (elem R S) (f.sum fun (i : I) (x : S) ↦ x ⊗ₜ[R] (b : (a : I) → S) i)),
    LE.le (α := Submodule R S) ⊤
      (Submodule.span R
        (↑(Finset.image₂
              (fun (i j : I) ↦ HMul.hMul (α := S) (β := S) ((f : (a : I) → S) i : S) ((b : (a : I) → S) j : S))
              f.support f.support) :
          Set S))
h₂ :
  let I := Free.ChooseBasisIndex R S;
  let b : Basis I R S := Free.chooseBasis R S;
  ∀ (f : I →₀ S) (hf : Eq (α := S ⊗[R] S) (elem R S) (f.sum fun (i : I) (x : S) ↦ x ⊗ₜ[R] (b : (a : I) → S) i)) ⦃x : S⦄,
    Membership.mem (γ := Submodule R S)
      (Submodule.span R
        (↑(Finset.image₂
              (fun (i j : I) ↦ HMul.hMul (α := S) (β := S) ((f : (a : I) → S) i : S) ((b : (a : I) → S) j : S))
              f.support f.support) :
          Set S))
      x
h₃ h₄ :
  let I := Free.ChooseBasisIndex R S;
  let b : Basis I R S := Free.chooseBasis R S;
  ∀ (f : I →₀ S) (hf : Eq (α := S ⊗[R] S) (elem R S) (f.sum fun (i : I) (x : S) ↦ x ⊗ₜ[R] (b : (a : I) → S) i)) ⦃x : S⦄,
    Membership.mem (γ := Submodule R S)
      (Submodule.span R
        (↑(Finset.image₂
              (fun (i j : I) ↦ HMul.hMul (α := S) (β := S) ((f : (a : I) → S) i : S) ((b : (a : I) → S) j : S))
              f.support f.support) :
          Set S))
      x
h₅ h₆ :
  let I := Free.ChooseBasisIndex R S;
  let b : Basis I R S := Free.chooseBasis R S;
  ∀ (f : I →₀ S) (hf : Eq (α := S ⊗[R] S) (elem R S) (f.sum fun (i : I) (x : S) ↦ x ⊗ₜ[R] (b : (a : I) → S) i)) ⦃x : S⦄,
    let a : I → I →₀ R := fun (i : I) ↦ (b.repr : (a : S) → I →₀ R) (HMul.hMul (α := S) ((b : (a : I) → S) i : S) x);
    ∀
      (hG :
        ∀ j ∉ f.support.biUnion fun (i : I) ↦ (a i).support,
          Eq (α := I →₀ R)
            ((b.repr : (a : S) → I →₀ R)
                (f.sum fun (i : I) (y : S) ↦ HSMul.hSMul.{u_1, u_2, u_2} (α := R) ((a i : (a : I) → R) j : R) y) :
              I →₀ R)
            (0 : I →₀ R)),
      Membership.mem (γ := Submodule R S)
        (Submodule.span R
          (↑(Finset.image₂
                (fun (i j : I) ↦ HMul.hMul (α := S) (β := S) ((f : (a : I) → S) i : S) ((b : (a : I) → S) j : S))
                f.support f.support) :
            Set S))
        x
h₇ :
  let I := Free.ChooseBasisIndex R S;
  let b : Basis I R S := Free.chooseBasis R S;
  ∀ (f : I →₀ S) (hf : Eq (α := S ⊗[R] S) (elem R S) (f.sum fun (i : I) (x : S) ↦ x ⊗ₜ[R] (b : (a : I) → S) i)) ⦃x : S⦄,
    let a : I → I →₀ R := fun (i : I) ↦ (b.repr : (a : S) → I →₀ R) (HMul.hMul (α := S) ((b : (a : I) → S) i : S) x);
    let F : I →₀ I →₀ R :=
      Finsupp.onFinset f.support
        (fun (j : I) ↦ (b.repr : (a : S) → I →₀ R) (HMul.hMul (β := S) x ((f : (a : I) → S) j : S))) ⋯;
    ∀
      (hG :
        ∀ j ∉ f.support.biUnion fun (i : I) ↦ (a i).support,
          Eq (α := I →₀ R)
            ((b.repr : (a : S) → I →₀ R)
                (f.sum fun (i : I) (y : S) ↦ HSMul.hSMul.{u_1, u_2, u_2} (α := R) ((a i : (a : I) → R) j : R) y) :
              I →₀ R)
            (0 : I →₀ R)),
      let G : I →₀ I →₀ R :=
        Finsupp.onFinset (f.support.biUnion fun (i : I) ↦ (a i).support)
          (fun (j : I) ↦
            (b.repr : (a : S) → I →₀ R)
              (f.sum fun (i : I) (y : S) ↦ HSMul.hSMul.{u_1, u_2, u_2} (α := R) ((a i : (a : I) → R) j : R) y))
          ⋯;
      ∀ (this : F = G),
        Membership.mem (γ := Submodule R S)
          (Submodule.span R
            (↑(Finset.image₂
                  (fun (i j : I) ↦ HMul.hMul (α := S) (β := S) ((f : (a : I) → S) i : S) ((b : (a : I) → S) j : S))
                  f.support f.support) :
              Set S))
          x
h₈ :
  let I := Free.ChooseBasisIndex R S;
  let b : Basis I R S := Free.chooseBasis R S;
  ∀ (f : I →₀ S) (hf : Eq (α := S ⊗[R] S) (elem R S) (f.sum fun (i : I) (x : S) ↦ x ⊗ₜ[R] (b : (a : I) → S) i)) ⦃x : S⦄,
    let a : I → I →₀ R := fun (i : I) ↦ (b.repr : (a : S) → I →₀ R) (HMul.hMul (α := S) ((b : (a : I) → S) i : S) x);
    let F : I →₀ I →₀ R :=
      Finsupp.onFinset f.support
        (fun (j : I) ↦ (b.repr : (a : S) → I →₀ R) (HMul.hMul (β := S) x ((f : (a : I) → S) j : S))) ⋯;
    ∀
      (hG :
        ∀ j ∉ f.support.biUnion fun (i : I) ↦ (a i).support,
          Eq (α := I →₀ R)
            ((b.repr : (a : S) → I →₀ R)
                (f.sum fun (i : I) (y : S) ↦ HSMul.hSMul.{u_1, u_2, u_2} (α := R) ((a i : (a : I) → R) j : R) y) :
              I →₀ R)
            (0 : I →₀ R)),
      let G : I →₀ I →₀ R :=
        Finsupp.onFinset (f.support.biUnion fun (i : I) ↦ (a i).support)
          (fun (j : I) ↦
            (b.repr : (a : S) → I →₀ R)
              (f.sum fun (i : I) (y : S) ↦ HSMul.hSMul.{u_1, u_2, u_2} (α := R) ((a i : (a : I) → R) j : R) y))
          ⋯;
      ∀ (this : F = G)
        (this :
          ∀ (j : I),
            HMul.hMul (β := S) x ((f : (a : I) → S) j : S) =
              f.sum fun (i : I) (y : S) ↦ HSMul.hSMul.{u_1, u_2, u_2} (α := R) ((a i : (a : I) → R) j : R) y),
        Membership.mem (γ := Submodule R S)
          (Submodule.span R
            (↑(Finset.image₂
                  (fun (i j : I) ↦ HMul.hMul (α := S) (β := S) ((f : (a : I) → S) i : S) ((b : (a : I) → S) j : S))
                  f.support f.support) :
              Set S))
          x
h₉ :
  let I := Free.ChooseBasisIndex R S;
  let b : Basis I R S := Free.chooseBasis R S;
  ∀ (f : I →₀ S) (hf : Eq (α := S ⊗[R] S) (elem R S) (f.sum fun (i : I) (x : S) ↦ x ⊗ₜ[R] (b : (a : I) → S) i)) ⦃x : S⦄,
    let a : I → I →₀ R := fun (i : I) ↦ (b.repr : (a : S) → I →₀ R) (HMul.hMul (α := S) ((b : (a : I) → S) i : S) x);
    let F : I →₀ I →₀ R :=
      Finsupp.onFinset f.support
        (fun (j : I) ↦ (b.repr : (a : S) → I →₀ R) (HMul.hMul (β := S) x ((f : (a : I) → S) j : S))) ⋯;
    ∀
      (hG :
        ∀ j ∉ f.support.biUnion fun (i : I) ↦ (a i).support,
          Eq (α := I →₀ R)
            ((b.repr : (a : S) → I →₀ R)
                (f.sum fun (i : I) (y : S) ↦ HSMul.hSMul.{u_1, u_2, u_2} (α := R) ((a i : (a : I) → R) j : R) y) :
              I →₀ R)
            (0 : I →₀ R)),
      let G : I →₀ I →₀ R :=
        Finsupp.onFinset (f.support.biUnion fun (i : I) ↦ (a i).support)
          (fun (j : I) ↦
            (b.repr : (a : S) → I →₀ R)
              (f.sum fun (i : I) (y : S) ↦ HSMul.hSMul.{u_1, u_2, u_2} (α := R) ((a i : (a : I) → R) j : R) y))
          ⋯;
      ∀ (this : F = G)
        (this :
          ∀ (j : I),
            HMul.hMul (β := S) x ((f : (a : I) → S) j : S) =
              f.sum fun (i : I) (y : S) ↦ HSMul.hSMul.{u_1, u_2, u_2} (α := R) ((a i : (a : I) → R) j : R) y),
        Membership.mem (γ := Submodule R S)
          (Submodule.span R
            (↑(Finset.image₂
                  (fun (i j : I) ↦ HMul.hMul (α := S) (β := S) ((f : (a : I) → S) i : S) ((b : (a : I) → S) j : S))
                  f.support f.support) :
              Set S))
          (∑ i ∈ f.support,
            HMul.hMul (β := S) x
              ((TensorProduct.lmul' R : (a : S ⊗[R] S) → S) ((f : (a : I) → S) i ⊗ₜ[R] (b : (a : I) → S) i : S ⊗[R] S) :
                S))
h₁₀ :
  let I := Free.ChooseBasisIndex R S;
  let b : Basis I R S := Free.chooseBasis R S;
  ∀ (f : I →₀ S) (hf : Eq (α := S ⊗[R] S) (elem R S) (f.sum fun (i : I) (x : S) ↦ x ⊗ₜ[R] (b : (a : I) → S) i)) ⦃x : S⦄,
    let a : I → I →₀ R := fun (i : I) ↦ (b.repr : (a : S) → I →₀ R) (HMul.hMul (α := S) ((b : (a : I) → S) i : S) x);
    let F : I →₀ I →₀ R :=
      Finsupp.onFinset f.support
        (fun (j : I) ↦ (b.repr : (a : S) → I →₀ R) (HMul.hMul (β := S) x ((f : (a : I) → S) j : S))) ⋯;
    ∀
      (hG :
        ∀ j ∉ f.support.biUnion fun (i : I) ↦ (a i).support,
          Eq (α := I →₀ R)
            ((b.repr : (a : S) → I →₀ R)
                (f.sum fun (i : I) (y : S) ↦ HSMul.hSMul.{u_1, u_2, u_2} (α := R) ((a i : (a : I) → R) j : R) y) :
              I →₀ R)
            (0 : I →₀ R)),
      let G : I →₀ I →₀ R :=
        Finsupp.onFinset (f.support.biUnion fun (i : I) ↦ (a i).support)
          (fun (j : I) ↦
            (b.repr : (a : S) → I →₀ R)
              (f.sum fun (i : I) (y : S) ↦ HSMul.hSMul.{u_1, u_2, u_2} (α := R) ((a i : (a : I) → R) j : R) y))
          ⋯;
      ∀ (this : F = G)
        (this :
          ∀ (j : I),
            HMul.hMul (β := S) x ((f : (a : I) → S) j : S) =
              f.sum fun (i : I) (y : S) ↦ HSMul.hSMul.{u_1, u_2, u_2} (α := R) ((a i : (a : I) → R) j : R) y),
        Membership.mem (γ := Submodule R S)
          (Submodule.span R
            (Set.image2
              (fun (i j : I) ↦ HMul.hMul (α := S) (β := S) ((f : (a : I) → S) i : S) ((b : (a : I) → S) j : S))
              (↑f.support : Set I) (↑f.support : Set I)))
          (∑ x ∈ f.support,
            ∑ x_1 ∈ f.support,
              HSMul.hSMul.{u_1, u_2, u_2} (α := R) ((a x_1 : (a : I) → R) x : R)
                (HMul.hMul (α := S) (β := S) ((f : (a : I) → S) x_1 : S) ((b : (a : I) → S) x : S)))
h₁₁ h₁₂ h₁₃ :
  let I := Free.ChooseBasisIndex R S;
  let b : Basis I R S := Free.chooseBasis R S;
  ∀ (f : I →₀ S) (hf : Eq (α := S ⊗[R] S) (elem R S) (f.sum fun (i : I) (x : S) ↦ x ⊗ₜ[R] (b : (a : I) → S) i)) ⦃x : S⦄,
    let a : I → I →₀ R := fun (i : I) ↦ (b.repr : (a : S) → I →₀ R) (HMul.hMul (α := S) ((b : (a : I) → S) i : S) x);
    let F : I →₀ I →₀ R :=
      Finsupp.onFinset f.support
        (fun (j : I) ↦ (b.repr : (a : S) → I →₀ R) (HMul.hMul (β := S) x ((f : (a : I) → S) j : S))) ⋯;
    ∀
      (hG :
        ∀ j ∉ f.support.biUnion fun (i : I) ↦ (a i).support,
          Eq (α := I →₀ R)
            ((b.repr : (a : S) → I →₀ R)
                (f.sum fun (i : I) (y : S) ↦ HSMul.hSMul.{u_1, u_2, u_2} (α := R) ((a i : (a : I) → R) j : R) y) :
              I →₀ R)
            (0 : I →₀ R)),
      let G : I →₀ I →₀ R :=
        Finsupp.onFinset (f.support.biUnion fun (i : I) ↦ (a i).support)
          (fun (j : I) ↦
            (b.repr : (a : S) → I →₀ R)
              (f.sum fun (i : I) (y : S) ↦ HSMul.hSMul.{u_1, u_2, u_2} (α := R) ((a i : (a : I) → R) j : R) y))
          ⋯;
      ∀ (this : F = G)
        (this :
          ∀ (j : I),
            HMul.hMul (β := S) x ((f : (a : I) → S) j : S) =
              f.sum fun (i : I) (y : S) ↦ HSMul.hSMul.{u_1, u_2, u_2} (α := R) ((a i : (a : I) → R) j : R) y)
        (i : I) (hi : i ∈ f.support),
        Membership.mem (γ := Submodule R S)
          (Submodule.span R
            (Set.image2
              (fun (i j : I) ↦ HMul.hMul (α := S) (β := S) ((f : (a : I) → S) i : S) ((b : (a : I) → S) j : S))
              (↑f.support : Set I) (↑f.support : Set I)))
          (∑ x ∈ f.support,
            HSMul.hSMul.{u_1, u_2, u_2} (α := R) ((a x : (a : I) → R) i : R)
              (HMul.hMul (α := S) (β := S) ((f : (a : I) → S) x : S) ((b : (a : I) → S) i : S)))
⊢ Module.Finite R S
have h₁₄ : let I := Free.ChooseBasisIndex R S;
let b : Basis I R S := Free.chooseBasis R S;
∀ (f : I →₀ S) (hf : Eq (α := S ⊗[R] S) (elem R S) (f.sum fun (i : I) (x : S) ↦ x ⊗ₜ[R] (b : (a : I) → S) i)) ⦃x : S⦄,
  let a : I → I →₀ R := fun (i : I) ↦ (b.repr : (a : S) → I →₀ R) (HMul.hMul (α := S) ((b : (a : I) → S) i : S) x);
  let F : I →₀ I →₀ R :=
    Finsupp.onFinset f.support
      (fun (j : I) ↦ (b.repr : (a : S) → I →₀ R) (HMul.hMul (β := S) x ((f : (a : I) → S) j : S))) sorry;
  ∀
    (hG :
      ∀ j ∉ f.support.biUnion fun (i : I) ↦ (a i).support,
        Eq (α := I →₀ R)
          ((b.repr : (a : S) → I →₀ R)
              (f.sum fun (i : I) (y : S) ↦ HSMul.hSMul.{u_1, u_2, u_2} (α := R) ((a i : (a : I) → R) j : R) y) :
            I →₀ R)
          (0 : I →₀ R)),
    let G : I →₀ I →₀ R :=
      Finsupp.onFinset (f.support.biUnion fun (i : I) ↦ (a i).support)
        (fun (j : I) ↦
          (b.repr : (a : S) → I →₀ R)
            (f.sum fun (i : I) (y : S) ↦ HSMul.hSMul.{u_1, u_2, u_2} (α := R) ((a i : (a : I) → R) j : R) y))
        sorry;
    ∀ (this : F = G)
      (this :
        ∀ (j : I),
          HMul.hMul (β := S) x ((f : (a : I) → S) j : S) =
            f.sum fun (i : I) (y : S) ↦ HSMul.hSMul.{u_1, u_2, u_2} (α := R) ((a i : (a : I) → R) j : R) y)
      (i : I) (hi : i ∈ f.support),
      ∀ c ∈ f.support,
        Membership.mem (γ := Submodule R S)
          (Submodule.span R
            (Set.image2
              (fun (i j : I) ↦ HMul.hMul (α := S) (β := S) ((f : (a : I) → S) i : S) ((b : (a : I) → S) j : S))
              (↑f.support : Set I) (↑f.support : Set I)))
          (HSMul.hSMul.{u_1, u_2, u_2} (α := R) ((a c : (a : I) → R) i : R)
            (HMul.hMul (α := S) (β := S) ((f : (a : I) → S) c : S) ((b : (a : I) → S) i : S)))
Tactic: classical
  let I := Module.Free.ChooseBasisIndex R S
  -- Let `bᵢ` be an `R`-basis of `S`.
  let b : Basis I R S := Module.Free.chooseBasis R S
  -- Let `∑ₛ fᵢ ⊗ bᵢ : S ⊗[R] S` (summing over some finite `s`) be an element such that
  -- `∑ₛ fᵢbᵢ = 1` and `∀ x : S, xfᵢ ⊗ bᵢ = aᵢ ⊗ xfᵢ` which exists since `S` is unramified over `R`.
  have ⟨f, hf⟩ : ∃ (a : I →₀ S), elem R S = a.sum (fun i x ↦ x ⊗ₜ b i) := by
    let b' := ((Basis.singleton PUnit.{1} S).tensorProduct b).reindex (Equiv.punitProd I)
    use b'.repr (elem R S)
    conv_lhs => rw [← b'.linearCombination_repr (elem R S), Finsupp.linearCombination_apply]
    congr! with _ i x
    simp [b', Basis.tensorProduct, TensorProduct.smul_tmul']
  constructor
  -- I claim that `{ fᵢbⱼ | i, j ∈ s }` spans `S` over `R`.
  use Finset.image₂ (fun i j ↦ f i * b j) f.support f.support
  rw [← top_le_iff]
  -- For all `x : S`, let `bᵢx = ∑ aᵢⱼbⱼ`.
  rintro x -
  let a : I → I →₀ R := fun i ↦ b.repr (b i * x)
  -- Consider `F` such that `fⱼx = ∑ Fᵢⱼbⱼ`.
  let F : I →₀ I →₀ R := Finsupp.onFinset f.support (fun j ↦ b.repr (x * f j))
    (fun j ↦ not_imp_comm.mp fun hj ↦ by simp [Finsupp.notMem_support_iff.mp hj])
  have hG : ∀ j ∉ (Finset.biUnion f.support fun i ↦ (a i).support),
      b.repr (f.sum (fun i y ↦ a i j • y)) = 0 := by
    intro j hj
    simp only [Finset.mem_biUnion, Finsupp.mem_support_iff, ne_eq, not_exists, not_and,
      not_not] at hj
    simp only [Finsupp.sum]
    trans b.repr (f.support.sum (fun _ ↦ 0))
    · refine congr_arg b.repr (Finset.sum_congr rfl ?_)
      simp only [Finsupp.mem_support_iff]
      intro i hi
      rw [hj i hi, zero_smul]
    · simp only [Finset.sum_const_zero, map_zero]
  -- And `G` such that `∑ₛ aᵢⱼfᵢ = ∑ Gᵢⱼbⱼ`, where `aᵢⱼ` are the coefficients `bᵢx = ∑ aᵢⱼbⱼ`.
  let G : I →₀ I →₀ R := Finsupp.onFinset (Finset.biUnion f.support (fun i ↦ (a i).support))
    (fun j ↦ b.repr (f.sum (fun i y ↦ a i j • y)))
    (fun j ↦ not_imp_comm.mp (hG j))
  -- Then `∑ Fᵢⱼ(bⱼ ⊗ bᵢ) = ∑ fⱼx ⊗ bᵢ = ∑ fⱼ ⊗ xbᵢ = ∑ aᵢⱼ(fⱼ ⊗ bᵢ) = ∑ Gᵢⱼ(bⱼ ⊗ bᵢ)`.
  -- Since `bⱼ ⊗ bᵢ` forms an `R`-basis of `S ⊗ S`, we conclude that `F = G`.
  have : F = G := by
    apply Finsupp.curryEquiv.symm.injective
    apply (Finsupp.equivCongrLeft (Equiv.prodComm I I)).injective
    apply (b.tensorProduct b).repr.symm.injective
    suffices (F.sum fun a f ↦ f.sum fun b' c ↦ c • b b' ⊗ₜ[R] b a) =
        G.sum fun a f ↦ f.sum fun b' c ↦ c • b b' ⊗ₜ[R] b a by
      simpa [Finsupp.linearCombination_apply, Finsupp.sum_uncurry_index]
    have : ∀ i, ((b.repr (x * f i)).sum fun j k ↦ k • b j ⊗ₜ[R] b i) = (x * f i) ⊗ₜ[R] b i := by
      intro i
      simp_rw [Finsupp.sum, TensorProduct.smul_tmul', ← TensorProduct.sum_tmul]
      congr 1
      exact b.linearCombination_repr _
    rw [Finsupp.onFinset_sum, Finsupp.onFinset_sum]
    · trans (x ⊗ₜ 1) * elem R S
      · simp_rw [this, hf, Finsupp.sum, Finset.mul_sum, TensorProduct.tmul_mul_tmul, one_mul]
      · rw [← one_tmul_mul_elem, hf, finite_of_free_aux]
        rfl
    · intro; simp
    · intro; simp
  -- In particular, `fⱼx = ∑ Fᵢⱼbⱼ = ∑ Gᵢⱼbⱼ = ∑ₛ aᵢⱼfᵢ` for all `j`.
  have : ∀ j, x * f j = f.sum fun i y ↦ a i j • y := by
    intro j
    apply b.repr.injective
    exact DFunLike.congr_fun this j
  -- Since `∑ₛ fⱼbⱼ = 1`, `x = ∑ₛ aᵢⱼfᵢbⱼ` is indeed in the span of `{ fᵢbⱼ | i, j ∈ s }`.
  rw [← mul_one x, ← @lmul_elem R, hf, map_finsuppSum, Finsupp.sum, Finset.mul_sum]
  simp only [TensorProduct.lmul'_apply_tmul, Finset.coe_image₂, ← mul_assoc, this,
    Finsupp.sum, Finset.sum_mul, smul_mul_assoc]
  apply Submodule.sum_mem; intro i hi
  apply Submodule.sum_mem; intro j hj
  apply Submodule.smul_mem
  apply Submodule.subset_span
  use j, hj, i, hi