l3lab/ntp-mathlib huggingface dataset:
theorem lieSpan_le {K} : lieSpan R L s ≤ K ↔ s ⊆ K := by
  constructor
  · exact Set.Subset.trans subset_lieSpan
  · intro hs m hm
    rw [mem_lieSpan] at hm
    

Proof state:
case mpr
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K✝ K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s : Set L
K : LieSubalgebra R L
hs : s ⊆ ↑K
m : L
hm : ∀ (K : LieSubalgebra R L), s ⊆ ↑K → m ∈ K
⊢ m ∈ K

Next tactic:
exact hm _ hs
theorem lieSpan_mono {t : Set L} (h : s ⊆ t) : lieSpan R L s ≤ lieSpan R L t := by
  

Proof state:
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s t : Set L
h : s ⊆ t
⊢ lieSpan R L s ≤ lieSpan R L t

Next tactic:
rw [lieSpan_le]
theorem lieSpan_mono {t : Set L} (h : s ⊆ t) : lieSpan R L s ≤ lieSpan R L t := by
  rw [lieSpan_le]
  

Proof state:
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s t : Set L
h : s ⊆ t
⊢ s ⊆ ↑(lieSpan R L t)

Next tactic:
exact Set.Subset.trans h subset_lieSpan
theorem coe_lieSpan_submodule_eq_iff {p : Submodule R L} :
    (lieSpan R L (p : Set L) : Submodule R L) = p ↔ ∃ K : LieSubalgebra R L, ↑K = p := by
  

Proof state:
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s : Set L
p : Submodule R L
⊢ (lieSpan R L ↑p).toSubmodule = p ↔ ∃ K, K.toSubmodule = p

Next tactic:
rw [p.exists_lieSubalgebra_coe_eq_iff]
theorem coe_lieSpan_submodule_eq_iff {p : Submodule R L} :
    (lieSpan R L (p : Set L) : Submodule R L) = p ↔ ∃ K : LieSubalgebra R L, ↑K = p := by
  rw [p.exists_lieSubalgebra_coe_eq_iff]; 

Proof state:
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s : Set L
p : Submodule R L
⊢ (lieSpan R L ↑p).toSubmodule = p ↔ ∀ (x y : L), x ∈ p → y ∈ p → ⁅x, y⁆ ∈ p

Next tactic:
constructor
theorem coe_lieSpan_submodule_eq_iff {p : Submodule R L} :
    (lieSpan R L (p : Set L) : Submodule R L) = p ↔ ∃ K : LieSubalgebra R L, ↑K = p := by
  rw [p.exists_lieSubalgebra_coe_eq_iff]; constructor <;> 

Proof state:
case mp
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s : Set L
p : Submodule R L
⊢ (lieSpan R L ↑p).toSubmodule = p → ∀ (x y : L), x ∈ p → y ∈ p → ⁅x, y⁆ ∈ p

Next tactic:
intro h
theorem coe_lieSpan_submodule_eq_iff {p : Submodule R L} :
    (lieSpan R L (p : Set L) : Submodule R L) = p ↔ ∃ K : LieSubalgebra R L, ↑K = p := by
  rw [p.exists_lieSubalgebra_coe_eq_iff]; constructor <;> 

Proof state:
case mpr
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s : Set L
p : Submodule R L
⊢ (∀ (x y : L), x ∈ p → y ∈ p → ⁅x, y⁆ ∈ p) → (lieSpan R L ↑p).toSubmodule = p

Next tactic:
intro h
theorem coe_lieSpan_submodule_eq_iff {p : Submodule R L} :
    (lieSpan R L (p : Set L) : Submodule R L) = p ↔ ∃ K : LieSubalgebra R L, ↑K = p := by
  rw [p.exists_lieSubalgebra_coe_eq_iff]; constructor <;> intro h
  · 

Proof state:
case mp
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s : Set L
p : Submodule R L
h : (lieSpan R L ↑p).toSubmodule = p
⊢ ∀ (x y : L), x ∈ p → y ∈ p → ⁅x, y⁆ ∈ p

Next tactic:
intro x m hm
theorem coe_lieSpan_submodule_eq_iff {p : Submodule R L} :
    (lieSpan R L (p : Set L) : Submodule R L) = p ↔ ∃ K : LieSubalgebra R L, ↑K = p := by
  rw [p.exists_lieSubalgebra_coe_eq_iff]; constructor <;> intro h
  · intro x m hm
    

Proof state:
case mp
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s : Set L
p : Submodule R L
h : (lieSpan R L ↑p).toSubmodule = p
x m : L
hm : x ∈ p
⊢ m ∈ p → ⁅x, m⁆ ∈ p

Next tactic:
rw [← h, mem_coe_submodule]
theorem coe_lieSpan_submodule_eq_iff {p : Submodule R L} :
    (lieSpan R L (p : Set L) : Submodule R L) = p ↔ ∃ K : LieSubalgebra R L, ↑K = p := by
  rw [p.exists_lieSubalgebra_coe_eq_iff]; constructor <;> intro h
  · intro x m hm
    rw [← h, mem_coe_submodule]
    

Proof state:
case mp
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s : Set L
p : Submodule R L
h : (lieSpan R L ↑p).toSubmodule = p
x m : L
hm : x ∈ p
⊢ m ∈ lieSpan R L ↑p → ⁅x, m⁆ ∈ (lieSpan R L ↑p).toSubmodule

Next tactic:
exact lie_mem _ (subset_lieSpan hm)
theorem coe_lieSpan_submodule_eq_iff {p : Submodule R L} :
    (lieSpan R L (p : Set L) : Submodule R L) = p ↔ ∃ K : LieSubalgebra R L, ↑K = p := by
  rw [p.exists_lieSubalgebra_coe_eq_iff]; constructor <;> intro h
  · intro x m hm
    rw [← h, mem_coe_submodule]
    exact lie_mem _ (subset_lieSpan hm)
  · 

Proof state:
case mpr
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s : Set L
p : Submodule R L
h : ∀ (x y : L), x ∈ p → y ∈ p → ⁅x, y⁆ ∈ p
⊢ (lieSpan R L ↑p).toSubmodule = p

Next tactic:
rw [← coe_to_submodule_mk p @h, coe_to_submodule, coe_to_submodule_eq_iff, lieSpan_eq]
/-- An injective Lie algebra morphism is an equivalence onto its range. -/
noncomputable def ofInjective (f : L₁ →ₗ⁅R⁆ L₂) (h : Function.Injective f) : L₁ ≃ₗ⁅R⁆ f.range :=
  { LinearEquiv.ofInjective (f : L₁ →ₗ[R] L₂) <| by 

Proof state:
R : Type u
L₁ : Type v
L₂ : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L₁
inst✝² : LieRing L₂
inst✝¹ : LieAlgebra R L₁
inst✝ : LieAlgebra R L₂
f : L₁ →ₗ⁅R⁆ L₂
h : Function.Injective ⇑f
⊢ Function.Injective ⇑↑f

Next tactic:
rwa [LieHom.coe_toLinearMap]
/-- Lie subalgebras that are equal as sets are equivalent as Lie algebras. -/
def ofEq (h : (L₁' : Set L₁) = L₁'') : L₁' ≃ₗ⁅R⁆ L₁'' :=
  { LinearEquiv.ofEq (L₁' : Submodule R L₁) (L₁'' : Submodule R L₁) (by
      

Proof state:
R : Type u
L₁ : Type v
L₂ : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L₁
inst✝² : LieRing L₂
inst✝¹ : LieAlgebra R L₁
inst✝ : LieAlgebra R L₂
L₁' L₁'' : LieSubalgebra R L₁
L₂' : LieSubalgebra R L₂
h : ↑L₁' = ↑L₁''
⊢ L₁'.toSubmodule = L₁''.toSubmodule

Next tactic:
ext x
/-- Lie subalgebras that are equal as sets are equivalent as Lie algebras. -/
def ofEq (h : (L₁' : Set L₁) = L₁'') : L₁' ≃ₗ⁅R⁆ L₁'' :=
  { LinearEquiv.ofEq (L₁' : Submodule R L₁) (L₁'' : Submodule R L₁) (by
      ext x
      

Proof state:
case h
R : Type u
L₁ : Type v
L₂ : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L₁
inst✝² : LieRing L₂
inst✝¹ : LieAlgebra R L₁
inst✝ : LieAlgebra R L₂
L₁' L₁'' : LieSubalgebra R L₁
L₂' : LieSubalgebra R L₂
h : ↑L₁' = ↑L₁''
x : L₁
⊢ x ∈ L₁'.toSubmodule ↔ x ∈ L₁''.toSubmodule

Next tactic:
change x ∈ (L₁' : Set L₁) ↔ x ∈ (L₁'' : Set L₁)
/-- Lie subalgebras that are equal as sets are equivalent as Lie algebras. -/
def ofEq (h : (L₁' : Set L₁) = L₁'') : L₁' ≃ₗ⁅R⁆ L₁'' :=
  { LinearEquiv.ofEq (L₁' : Submodule R L₁) (L₁'' : Submodule R L₁) (by
      ext x
      change x ∈ (L₁' : Set L₁) ↔ x ∈ (L₁'' : Set L₁)
      

Proof state:
case h
R : Type u
L₁ : Type v
L₂ : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L₁
inst✝² : LieRing L₂
inst✝¹ : LieAlgebra R L₁
inst✝ : LieAlgebra R L₂
L₁' L₁'' : LieSubalgebra R L₁
L₂' : LieSubalgebra R L₂
h : ↑L₁' = ↑L₁''
x : L₁
⊢ x ∈ ↑L₁' ↔ x ∈ ↑L₁''

Next tactic:
rw [h]
/-- An equivalence of Lie algebras restricts to an equivalence from any Lie subalgebra onto its
image. -/
def lieSubalgebraMap : L₁'' ≃ₗ⁅R⁆ (L₁''.map e : LieSubalgebra R L₂) :=
  { LinearEquiv.submoduleMap (e : L₁ ≃ₗ[R] L₂) ↑L₁'' with
    map_lie' := @fun x y ↦ by
      

Proof state:
R : Type u
L₁ : Type v
L₂ : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L₁
inst✝² : LieRing L₂
inst✝¹ : LieAlgebra R L₁
inst✝ : LieAlgebra R L₂
L₁' L₁'' : LieSubalgebra R L₁
L₂' : LieSubalgebra R L₂
e : L₁ ≃ₗ⁅R⁆ L₂
src✝ : ↥L₁''.toSubmodule ≃ₗ[R] ↥(Submodule.map (↑(toLinearEquiv e)) L₁''.toSubmodule) :=
  LinearEquiv.submoduleMap (toLinearEquiv e) L₁''.toSubmodule
x y : ↥L₁''
⊢ AddHom.toFun src✝.toAddHom ⁅x, y⁆ = ⁅AddHom.toFun src✝.toAddHom x, AddHom.toFun src✝.toAddHom y⁆

Next tactic:
apply SetCoe.ext
/-- An equivalence of Lie algebras restricts to an equivalence from any Lie subalgebra onto its
image. -/
def lieSubalgebraMap : L₁'' ≃ₗ⁅R⁆ (L₁''.map e : LieSubalgebra R L₂) :=
  { LinearEquiv.submoduleMap (e : L₁ ≃ₗ[R] L₂) ↑L₁'' with
    map_lie' := @fun x y ↦ by
      apply SetCoe.ext
      

Proof state:
case a
R : Type u
L₁ : Type v
L₂ : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L₁
inst✝² : LieRing L₂
inst✝¹ : LieAlgebra R L₁
inst✝ : LieAlgebra R L₂
L₁' L₁'' : LieSubalgebra R L₁
L₂' : LieSubalgebra R L₂
e : L₁ ≃ₗ⁅R⁆ L₂
src✝ : ↥L₁''.toSubmodule ≃ₗ[R] ↥(Submodule.map (↑(toLinearEquiv e)) L₁''.toSubmodule) :=
  LinearEquiv.submoduleMap (toLinearEquiv e) L₁''.toSubmodule
x y : ↥L₁''
⊢ ↑(AddHom.toFun src✝.toAddHom ⁅x, y⁆) = ↑⁅AddHom.toFun src✝.toAddHom x, AddHom.toFun src✝.toAddHom y⁆

Next tactic:
exact LieHom.map_lie (↑e : L₁ →ₗ⁅R⁆ L₂) ↑x ↑y
/-- An equivalence of Lie algebras restricts to an equivalence from any Lie subalgebra onto its
image. -/
def ofSubalgebras (h : L₁'.map ↑e = L₂') : L₁' ≃ₗ⁅R⁆ L₂' :=
  { LinearEquiv.ofSubmodules (e : L₁ ≃ₗ[R] L₂) (↑L₁') (↑L₂') (by
      

Proof state:
R : Type u
L₁ : Type v
L₂ : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L₁
inst✝² : LieRing L₂
inst✝¹ : LieAlgebra R L₁
inst✝ : LieAlgebra R L₂
L₁' L₁'' : LieSubalgebra R L₁
L₂' : LieSubalgebra R L₂
e : L₁ ≃ₗ⁅R⁆ L₂
h : LieSubalgebra.map e.toLieHom L₁' = L₂'
⊢ Submodule.map (↑(toLinearEquiv e)) L₁'.toSubmodule = L₂'.toSubmodule

Next tactic:
rw [← h]
/-- An equivalence of Lie algebras restricts to an equivalence from any Lie subalgebra onto its
image. -/
def ofSubalgebras (h : L₁'.map ↑e = L₂') : L₁' ≃ₗ⁅R⁆ L₂' :=
  { LinearEquiv.ofSubmodules (e : L₁ ≃ₗ[R] L₂) (↑L₁') (↑L₂') (by
      rw [← h]
      

Proof state:
R : Type u
L₁ : Type v
L₂ : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L₁
inst✝² : LieRing L₂
inst✝¹ : LieAlgebra R L₁
inst✝ : LieAlgebra R L₂
L₁' L₁'' : LieSubalgebra R L₁
L₂' : LieSubalgebra R L₂
e : L₁ ≃ₗ⁅R⁆ L₂
h : LieSubalgebra.map e.toLieHom L₁' = L₂'
⊢ Submodule.map (↑(toLinearEquiv e)) L₁'.toSubmodule = (LieSubalgebra.map e.toLieHom L₁').toSubmodule

Next tactic:
rfl
/-- An equivalence of Lie algebras restricts to an equivalence from any Lie subalgebra onto its
image. -/
def ofSubalgebras (h : L₁'.map ↑e = L₂') : L₁' ≃ₗ⁅R⁆ L₂' :=
  { LinearEquiv.ofSubmodules (e : L₁ ≃ₗ[R] L₂) (↑L₁') (↑L₂') (by
      rw [← h]
      rfl) with
    map_lie' := @fun x y ↦ by
      

Proof state:
R : Type u
L₁ : Type v
L₂ : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L₁
inst✝² : LieRing L₂
inst✝¹ : LieAlgebra R L₁
inst✝ : LieAlgebra R L₂
L₁' L₁'' : LieSubalgebra R L₁
L₂' : LieSubalgebra R L₂
e : L₁ ≃ₗ⁅R⁆ L₂
h : LieSubalgebra.map e.toLieHom L₁' = L₂'
src✝ : ↥L₁'.toSubmodule ≃ₗ[R] ↥L₂'.toSubmodule :=
  LinearEquiv.ofSubmodules (toLinearEquiv e) L₁'.toSubmodule L₂'.toSubmodule
    (_ : Submodule.map (↑(toLinearEquiv e)) L₁'.toSubmodule = L₂'.toSubmodule)
x y : ↥L₁'
⊢ AddHom.toFun src✝.toAddHom ⁅x, y⁆ = ⁅AddHom.toFun src✝.toAddHom x, AddHom.toFun src✝.toAddHom y⁆

Next tactic:
apply SetCoe.ext
/-- An equivalence of Lie algebras restricts to an equivalence from any Lie subalgebra onto its
image. -/
def ofSubalgebras (h : L₁'.map ↑e = L₂') : L₁' ≃ₗ⁅R⁆ L₂' :=
  { LinearEquiv.ofSubmodules (e : L₁ ≃ₗ[R] L₂) (↑L₁') (↑L₂') (by
      rw [← h]
      rfl) with
    map_lie' := @fun x y ↦ by
      apply SetCoe.ext
      

Proof state:
case a
R : Type u
L₁ : Type v
L₂ : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L₁
inst✝² : LieRing L₂
inst✝¹ : LieAlgebra R L₁
inst✝ : LieAlgebra R L₂
L₁' L₁'' : LieSubalgebra R L₁
L₂' : LieSubalgebra R L₂
e : L₁ ≃ₗ⁅R⁆ L₂
h : LieSubalgebra.map e.toLieHom L₁' = L₂'
src✝ : ↥L₁'.toSubmodule ≃ₗ[R] ↥L₂'.toSubmodule :=
  LinearEquiv.ofSubmodules (toLinearEquiv e) L₁'.toSubmodule L₂'.toSubmodule
    (_ : Submodule.map (↑(toLinearEquiv e)) L₁'.toSubmodule = L₂'.toSubmodule)
x y : ↥L₁'
⊢ ↑(AddHom.toFun src✝.toAddHom ⁅x, y⁆) = ↑⁅AddHom.toFun src✝.toAddHom x, AddHom.toFun src✝.toAddHom y⁆

Next tactic:
exact LieHom.map_lie (↑e : L₁ →ₗ⁅R⁆ L₂) ↑x ↑y
/-- Two multilinear maps indexed by `Fin n` are equal if they are equal when all arguments are
basis vectors. -/
theorem Basis.ext_multilinear_fin {f g : MultilinearMap R M M₂} {ι₁ : Fin n → Type*}
    (e : ∀ i, Basis (ι₁ i) R (M i))
    (h : ∀ v : ∀ i, ι₁ i, (f fun i => e i (v i)) = g fun i => e i (v i)) : f = g := by
  

Proof state:
R : Type u_1
ι : Type u_2
n : ℕ
M : Fin n → Type u_3
M₂ : Type u_4
M₃ : Type u_5
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : AddCommMonoid M₃
inst✝³ : (i : Fin n) → AddCommMonoid (M i)
inst✝² : (i : Fin n) → Module R (M i)
inst✝¹ : Module R M₂
inst✝ : Module R M₃
f g : MultilinearMap R M M₂
ι₁ : Fin n → Type u_6
e : (i : Fin n) → Basis (ι₁ i) R (M i)
h : ∀ (v : (i : Fin n) → ι₁ i), (f fun i => (e i) (v i)) = g fun i => (e i) (v i)
⊢ f = g

Next tactic:
induction' n with m hm
/-- Two multilinear maps indexed by `Fin n` are equal if they are equal when all arguments are
basis vectors. -/
theorem Basis.ext_multilinear_fin {f g : MultilinearMap R M M₂} {ι₁ : Fin n → Type*}
    (e : ∀ i, Basis (ι₁ i) R (M i))
    (h : ∀ v : ∀ i, ι₁ i, (f fun i => e i (v i)) = g fun i => e i (v i)) : f = g := by
  induction' n with m hm
  · 

Proof state:
case zero
R : Type u_1
ι : Type u_2
M₂ : Type u_4
M₃ : Type u_5
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : AddCommMonoid M₃
inst✝³ : Module R M₂
inst✝² : Module R M₃
M : Fin Nat.zero → Type u_3
inst✝¹ : (i : Fin Nat.zero) → AddCommMonoid (M i)
inst✝ : (i : Fin Nat.zero) → Module R (M i)
f g : MultilinearMap R M M₂
ι₁ : Fin Nat.zero → Type u_6
e : (i : Fin Nat.zero) → Basis (ι₁ i) R (M i)
h : ∀ (v : (i : Fin Nat.zero) → ι₁ i), (f fun i => (e i) (v i)) = g fun i => (e i) (v i)
⊢ f = g

Next tactic:
ext x
/-- Two multilinear maps indexed by `Fin n` are equal if they are equal when all arguments are
basis vectors. -/
theorem Basis.ext_multilinear_fin {f g : MultilinearMap R M M₂} {ι₁ : Fin n → Type*}
    (e : ∀ i, Basis (ι₁ i) R (M i))
    (h : ∀ v : ∀ i, ι₁ i, (f fun i => e i (v i)) = g fun i => e i (v i)) : f = g := by
  induction' n with m hm
  · ext x
    

Proof state:
case zero.H
R : Type u_1
ι : Type u_2
M₂ : Type u_4
M₃ : Type u_5
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : AddCommMonoid M₃
inst✝³ : Module R M₂
inst✝² : Module R M₃
M : Fin Nat.zero → Type u_3
inst✝¹ : (i : Fin Nat.zero) → AddCommMonoid (M i)
inst✝ : (i : Fin Nat.zero) → Module R (M i)
f g : MultilinearMap R M M₂
ι₁ : Fin Nat.zero → Type u_6
e : (i : Fin Nat.zero) → Basis (ι₁ i) R (M i)
h : ∀ (v : (i : Fin Nat.zero) → ι₁ i), (f fun i => (e i) (v i)) = g fun i => (e i) (v i)
x : (i : Fin Nat.zero) → M i
⊢ f x = g x

Next tactic:
convert h finZeroElim
/-- Two multilinear maps indexed by `Fin n` are equal if they are equal when all arguments are
basis vectors. -/
theorem Basis.ext_multilinear_fin {f g : MultilinearMap R M M₂} {ι₁ : Fin n → Type*}
    (e : ∀ i, Basis (ι₁ i) R (M i))
    (h : ∀ v : ∀ i, ι₁ i, (f fun i => e i (v i)) = g fun i => e i (v i)) : f = g := by
  induction' n with m hm
  · ext x
    convert h finZeroElim
  · 

Proof state:
case succ
R : Type u_1
ι : Type u_2
M₂ : Type u_4
M₃ : Type u_5
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : AddCommMonoid M₃
inst✝³ : Module R M₂
inst✝² : Module R M₃
m : ℕ
hm :
  ∀ {M : Fin m → Type u_3} [inst : (i : Fin m) → AddCommMonoid (M i)] [inst_1 : (i : Fin m) → Module R (M i)]
    {f g : MultilinearMap R M M₂} {ι₁ : Fin m → Type u_6} (e : (i : Fin m) → Basis (ι₁ i) R (M i)),
    (∀ (v : (i : Fin m) → ι₁ i), (f fun i => (e i) (v i)) = g fun i => (e i) (v i)) → f = g
M : Fin (Nat.succ m) → Type u_3
inst✝¹ : (i : Fin (Nat.succ m)) → AddCommMonoid (M i)
inst✝ : (i : Fin (Nat.succ m)) → Module R (M i)
f g : MultilinearMap R M M₂
ι₁ : Fin (Nat.succ m) → Type u_6
e : (i : Fin (Nat.succ m)) → Basis (ι₁ i) R (M i)
h : ∀ (v : (i : Fin (Nat.succ m)) → ι₁ i), (f fun i => (e i) (v i)) = g fun i => (e i) (v i)
⊢ f = g

Next tactic:
apply Function.LeftInverse.injective uncurry_curryLeft
/-- Two multilinear maps indexed by `Fin n` are equal if they are equal when all arguments are
basis vectors. -/
theorem Basis.ext_multilinear_fin {f g : MultilinearMap R M M₂} {ι₁ : Fin n → Type*}
    (e : ∀ i, Basis (ι₁ i) R (M i))
    (h : ∀ v : ∀ i, ι₁ i, (f fun i => e i (v i)) = g fun i => e i (v i)) : f = g := by
  induction' n with m hm
  · ext x
    convert h finZeroElim
  · apply Function.LeftInverse.injective uncurry_curryLeft
    

Proof state:
case succ.a
R : Type u_1
ι : Type u_2
M₂ : Type u_4
M₃ : Type u_5
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : AddCommMonoid M₃
inst✝³ : Module R M₂
inst✝² : Module R M₃
m : ℕ
hm :
  ∀ {M : Fin m → Type u_3} [inst : (i : Fin m) → AddCommMonoid (M i)] [inst_1 : (i : Fin m) → Module R (M i)]
    {f g : MultilinearMap R M M₂} {ι₁ : Fin m → Type u_6} (e : (i : Fin m) → Basis (ι₁ i) R (M i)),
    (∀ (v : (i : Fin m) → ι₁ i), (f fun i => (e i) (v i)) = g fun i => (e i) (v i)) → f = g
M : Fin (Nat.succ m) → Type u_3
inst✝¹ : (i : Fin (Nat.succ m)) → AddCommMonoid (M i)
inst✝ : (i : Fin (Nat.succ m)) → Module R (M i)
f g : MultilinearMap R M M₂
ι₁ : Fin (Nat.succ m) → Type u_6
e : (i : Fin (Nat.succ m)) → Basis (ι₁ i) R (M i)
h : ∀ (v : (i : Fin (Nat.succ m)) → ι₁ i), (f fun i => (e i) (v i)) = g fun i => (e i) (v i)
⊢ (fun x => curryLeft x) f = (fun x => curryLeft x) g

Next tactic:
refine' Basis.ext (e 0) _
/-- Two multilinear maps indexed by `Fin n` are equal if they are equal when all arguments are
basis vectors. -/
theorem Basis.ext_multilinear_fin {f g : MultilinearMap R M M₂} {ι₁ : Fin n → Type*}
    (e : ∀ i, Basis (ι₁ i) R (M i))
    (h : ∀ v : ∀ i, ι₁ i, (f fun i => e i (v i)) = g fun i => e i (v i)) : f = g := by
  induction' n with m hm
  · ext x
    convert h finZeroElim
  · apply Function.LeftInverse.injective uncurry_curryLeft
    refine' Basis.ext (e 0) _
    

Proof state:
case succ.a
R : Type u_1
ι : Type u_2
M₂ : Type u_4
M₃ : Type u_5
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : AddCommMonoid M₃
inst✝³ : Module R M₂
inst✝² : Module R M₃
m : ℕ
hm :
  ∀ {M : Fin m → Type u_3} [inst : (i : Fin m) → AddCommMonoid (M i)] [inst_1 : (i : Fin m) → Module R (M i)]
    {f g : MultilinearMap R M M₂} {ι₁ : Fin m → Type u_6} (e : (i : Fin m) → Basis (ι₁ i) R (M i)),
    (∀ (v : (i : Fin m) → ι₁ i), (f fun i => (e i) (v i)) = g fun i => (e i) (v i)) → f = g
M : Fin (Nat.succ m) → Type u_3
inst✝¹ : (i : Fin (Nat.succ m)) → AddCommMonoid (M i)
inst✝ : (i : Fin (Nat.succ m)) → Module R (M i)
f g : MultilinearMap R M M₂
ι₁ : Fin (Nat.succ m) → Type u_6
e : (i : Fin (Nat.succ m)) → Basis (ι₁ i) R (M i)
h : ∀ (v : (i : Fin (Nat.succ m)) → ι₁ i), (f fun i => (e i) (v i)) = g fun i => (e i) (v i)
⊢ ∀ (i : ι₁ 0), ((fun x => curryLeft x) f) ((e 0) i) = ((fun x => curryLeft x) g) ((e 0) i)

Next tactic:
intro i
/-- Two multilinear maps indexed by `Fin n` are equal if they are equal when all arguments are
basis vectors. -/
theorem Basis.ext_multilinear_fin {f g : MultilinearMap R M M₂} {ι₁ : Fin n → Type*}
    (e : ∀ i, Basis (ι₁ i) R (M i))
    (h : ∀ v : ∀ i, ι₁ i, (f fun i => e i (v i)) = g fun i => e i (v i)) : f = g := by
  induction' n with m hm
  · ext x
    convert h finZeroElim
  · apply Function.LeftInverse.injective uncurry_curryLeft
    refine' Basis.ext (e 0) _
    intro i
    

Proof state:
case succ.a
R : Type u_1
ι : Type u_2
M₂ : Type u_4
M₃ : Type u_5
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : AddCommMonoid M₃
inst✝³ : Module R M₂
inst✝² : Module R M₃
m : ℕ
hm :
  ∀ {M : Fin m → Type u_3} [inst : (i : Fin m) → AddCommMonoid (M i)] [inst_1 : (i : Fin m) → Module R (M i)]
    {f g : MultilinearMap R M M₂} {ι₁ : Fin m → Type u_6} (e : (i : Fin m) → Basis (ι₁ i) R (M i)),
    (∀ (v : (i : Fin m) → ι₁ i), (f fun i => (e i) (v i)) = g fun i => (e i) (v i)) → f = g
M : Fin (Nat.succ m) → Type u_3
inst✝¹ : (i : Fin (Nat.succ m)) → AddCommMonoid (M i)
inst✝ : (i : Fin (Nat.succ m)) → Module R (M i)
f g : MultilinearMap R M M₂
ι₁ : Fin (Nat.succ m) → Type u_6
e : (i : Fin (Nat.succ m)) → Basis (ι₁ i) R (M i)
h : ∀ (v : (i : Fin (Nat.succ m)) → ι₁ i), (f fun i => (e i) (v i)) = g fun i => (e i) (v i)
i : ι₁ 0
⊢ ((fun x => curryLeft x) f) ((e 0) i) = ((fun x => curryLeft x) g) ((e 0) i)

Next tactic:
apply hm (Fin.tail e)
/-- Two multilinear maps indexed by `Fin n` are equal if they are equal when all arguments are
basis vectors. -/
theorem Basis.ext_multilinear_fin {f g : MultilinearMap R M M₂} {ι₁ : Fin n → Type*}
    (e : ∀ i, Basis (ι₁ i) R (M i))
    (h : ∀ v : ∀ i, ι₁ i, (f fun i => e i (v i)) = g fun i => e i (v i)) : f = g := by
  induction' n with m hm
  · ext x
    convert h finZeroElim
  · apply Function.LeftInverse.injective uncurry_curryLeft
    refine' Basis.ext (e 0) _
    intro i
    apply hm (Fin.tail e)
    

Proof state:
case succ.a
R : Type u_1
ι : Type u_2
M₂ : Type u_4
M₃ : Type u_5
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : AddCommMonoid M₃
inst✝³ : Module R M₂
inst✝² : Module R M₃
m : ℕ
hm :
  ∀ {M : Fin m → Type u_3} [inst : (i : Fin m) → AddCommMonoid (M i)] [inst_1 : (i : Fin m) → Module R (M i)]
    {f g : MultilinearMap R M M₂} {ι₁ : Fin m → Type u_6} (e : (i : Fin m) → Basis (ι₁ i) R (M i)),
    (∀ (v : (i : Fin m) → ι₁ i), (f fun i => (e i) (v i)) = g fun i => (e i) (v i)) → f = g
M : Fin (Nat.succ m) → Type u_3
inst✝¹ : (i : Fin (Nat.succ m)) → AddCommMonoid (M i)
inst✝ : (i : Fin (Nat.succ m)) → Module R (M i)
f g : MultilinearMap R M M₂
ι₁ : Fin (Nat.succ m) → Type u_6
e : (i : Fin (Nat.succ m)) → Basis (ι₁ i) R (M i)
h : ∀ (v : (i : Fin (Nat.succ m)) → ι₁ i), (f fun i => (e i) (v i)) = g fun i => (e i) (v i)
i : ι₁ 0
⊢ ∀ (v : (i : Fin m) → ι₁ (Fin.succ i)),
    ((((fun x => curryLeft x) f) ((e 0) i)) fun i => (Fin.tail e i) (v i)) =
      (((fun x => curryLeft x) g) ((e 0) i)) fun i => (Fin.tail e i) (v i)

Next tactic:
intro j