Theorem: Module.End.eigenspaces_independent
File: Mathlib/LinearAlgebra/Eigenspace/Basic.lean

tactic: let S : @LinearMap K K _ _ (RingHom.id K) (Π₀ μ : K, f.eigenspace μ) V
    (@Dfinsupp.addCommMonoid K (fun μ => f.eigenspace μ) _) _
    (@Dfinsupp.module K _ (fun μ => f.eigenspace μ) _ _ _) _ :=
  @Dfinsupp.lsum K K ℕ _ V _ _ _ _ _ _ _ _ _ fun μ => (f.eigenspace μ).subtype
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
⊢ CompleteLattice.Independent (eigenspace f)

tactic: suffices ∀ l : Π₀ μ, f.eigenspace μ, S l = 0 → l = 0 by
  rw [CompleteLattice.independent_iff_dfinsupp_lsum_injective]
  change Function.Injective S
  rw [←  @LinearMap.ker_eq_bot K K (Π₀ μ, f.eigenspace μ) V _ _
    (@Dfinsupp.addCommGroup K (fun μ => f.eigenspace μ) _)]
  rw [eq_bot_iff]
  exact this
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
⊢ CompleteLattice.Independent (eigenspace f)

tactic: intro l hl
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
⊢ ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → l = 0

tactic: induction' h_l_support : l.support using Finset.induction with μ₀ l_support' hμ₀ ih generalizing l
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
⊢ l = 0

tactic: rw [CompleteLattice.independent_iff_dfinsupp_lsum_injective]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
this : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → l = 0
⊢ CompleteLattice.Independent (eigenspace f)

tactic: change Function.Injective S
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
this : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → l = 0
⊢ Function.Injective ↑(↑(Dfinsupp.lsum ℕ) fun i => Submodule.subtype (eigenspace f i))

tactic: rw [←  @LinearMap.ker_eq_bot K K (Π₀ μ, f.eigenspace μ) V _ _
  (@Dfinsupp.addCommGroup K (fun μ => f.eigenspace μ) _)]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
this : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → l = 0
⊢ Function.Injective ↑S

tactic: rw [eq_bot_iff]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
this : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → l = 0
⊢ LinearMap.ker S = ⊥

tactic: exact this
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
this : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → l = 0
⊢ LinearMap.ker S ≤ ⊥

tactic: exact Dfinsupp.support_eq_empty.1 h_l_support
state_before: case empty
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = ∅
⊢ l = 0

tactic: let l' := Dfinsupp.mapRange.linearMap
  (fun μ => (μ - μ₀) • @LinearMap.id K (f.eigenspace μ) _ _ _) l
state_before: case insert
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
⊢ l = 0

tactic: have h_l_support' : l'.support = l_support' := by
  rw [← Finset.erase_insert hμ₀, ← h_l_support]
  ext a
  have : ¬(a = μ₀ ∨ l a = 0) ↔ ¬a = μ₀ ∧ ¬l a = 0 := not_or
  simp only [Dfinsupp.mapRange.linearMap_apply, Dfinsupp.mapRange_apply,
    Dfinsupp.mem_support_iff, Finset.mem_erase, id.def, LinearMap.id_coe, LinearMap.smul_apply,
    Ne.def, smul_eq_zero, sub_eq_zero, this]
state_before: case insert
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
⊢ l = 0

tactic: have l'_eq_0 := ih l' total_l' h_l_support'
state_before: case insert
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
⊢ l = 0

tactic: have h_smul_eq_0 : ∀ μ, (μ - μ₀) • l μ = 0 := by
  intro μ
  calc
    (μ - μ₀) • l μ = l' μ := by
      simp only [LinearMap.id_coe, id.def, LinearMap.smul_apply, Dfinsupp.mapRange_apply,
        Dfinsupp.mapRange.linearMap_apply]
    _ = 0 := by rw [l'_eq_0]; rfl
state_before: case insert
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
⊢ l = 0

tactic: have h_lμ_eq_0 : ∀ μ : K, μ ≠ μ₀ → l μ = 0 := by
  intro μ hμ
  apply or_iff_not_imp_left.1 (smul_eq_zero.1 (h_smul_eq_0 μ))
  rwa [sub_eq_zero]
state_before: case insert
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
h_smul_eq_0 : ∀ (μ : K), (μ - μ₀) • ↑l μ = 0
⊢ l = 0

tactic: have h_sum_l_support'_eq_0 : (Finset.sum l_support' fun μ => (l μ : V)) = 0 := by
  rw [← Finset.sum_const_zero]
  apply Finset.sum_congr rfl
  intro μ hμ
  rw [Submodule.coe_eq_zero, h_lμ_eq_0]
  rintro rfl
  exact hμ₀ hμ
state_before: case insert
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
h_smul_eq_0 : ∀ (μ : K), (μ - μ₀) • ↑l μ = 0
h_lμ_eq_0 : ∀ (μ : K), μ ≠ μ₀ → ↑l μ = 0
⊢ l = 0

tactic: have : l μ₀ = 0 := by
  simp only [Dfinsupp.lsum_apply_apply, Dfinsupp.sumAddHom_apply,
    LinearMap.toAddMonoidHom_coe, Dfinsupp.sum, h_l_support, Submodule.subtype_apply,
    Submodule.coe_eq_zero, Finset.sum_insert hμ₀, h_sum_l_support'_eq_0, add_zero] at hl
  exact hl
state_before: case insert
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
h_smul_eq_0 : ∀ (μ : K), (μ - μ₀) • ↑l μ = 0
h_lμ_eq_0 : ∀ (μ : K), μ ≠ μ₀ → ↑l μ = 0
h_sum_l_support'_eq_0 : (Finset.sum l_support' fun μ => ↑(↑l μ)) = 0
⊢ l = 0

tactic: show l = 0
state_before: case insert
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
h_smul_eq_0 : ∀ (μ : K), (μ - μ₀) • ↑l μ = 0
h_lμ_eq_0 : ∀ (μ : K), μ ≠ μ₀ → ↑l μ = 0
h_sum_l_support'_eq_0 : (Finset.sum l_support' fun μ => ↑(↑l μ)) = 0
this : ↑l μ₀ = 0
⊢ l = 0

tactic: rw [← Finset.erase_insert hμ₀, ← h_l_support]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
⊢ Dfinsupp.support l' = l_support'

tactic: ext a
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
⊢ Dfinsupp.support l' = Finset.erase (Dfinsupp.support l) μ₀

tactic: have : ¬(a = μ₀ ∨ l a = 0) ↔ ¬a = μ₀ ∧ ¬l a = 0 := not_or
state_before: case a
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
a : K
⊢ a ∈ Dfinsupp.support l' ↔ a ∈ Finset.erase (Dfinsupp.support l) μ₀

tactic: simp only [Dfinsupp.mapRange.linearMap_apply, Dfinsupp.mapRange_apply,
  Dfinsupp.mem_support_iff, Finset.mem_erase, id.def, LinearMap.id_coe, LinearMap.smul_apply,
  Ne.def, smul_eq_zero, sub_eq_zero, this]
state_before: case a
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
a : K
this : ¬(a = μ₀ ∨ ↑l a = 0) ↔ ¬a = μ₀ ∧ ¬↑l a = 0
⊢ a ∈ Dfinsupp.support l' ↔ a ∈ Finset.erase (Dfinsupp.support l) μ₀

tactic: let g := f - algebraMap K (End K V) μ₀
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
⊢ ↑S l' = 0

tactic: let a : Π₀ _ : K, V := Dfinsupp.mapRange.linearMap (fun μ => (f.eigenspace μ).subtype) l
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
g : End K V := f - ↑(algebraMap K (End K V)) μ₀
⊢ ↑S l' = 0

tactic: calc
  S l' =
    Dfinsupp.lsum ℕ (fun μ => (f.eigenspace μ).subtype.comp ((μ - μ₀) • LinearMap.id)) l := ?_
  _ = Dfinsupp.lsum ℕ (fun μ => g.comp (f.eigenspace μ).subtype) l := ?_
  _ = Dfinsupp.lsum ℕ (fun _ => g) a := ?_
  _ = g (Dfinsupp.lsum ℕ (fun _ => (LinearMap.id : V →ₗ[K] V)) a) := ?_
  _ = g (S l) := ?_
  _ = 0 := by rw [hl, g.map_zero]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
g : End K V := f - ↑(algebraMap K (End K V)) μ₀
a : Π₀ (x : K), V := ↑(Dfinsupp.mapRange.linearMap fun μ => Submodule.subtype (eigenspace f μ)) l
⊢ ↑S l' = 0

tactic: rw [hl, g.map_zero]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
g : End K V := f - ↑(algebraMap K (End K V)) μ₀
a : Π₀ (x : K), V := ↑(Dfinsupp.mapRange.linearMap fun μ => Submodule.subtype (eigenspace f μ)) l
⊢ ↑g (↑S l) = 0

tactic: exact Dfinsupp.sum_mapRange_index.linearMap
state_before: case calc_1
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
g : End K V := f - ↑(algebraMap K (End K V)) μ₀
a : Π₀ (x : K), V := ↑(Dfinsupp.mapRange.linearMap fun μ => Submodule.subtype (eigenspace f μ)) l
⊢ ↑S l' = ↑(↑(Dfinsupp.lsum ℕ) fun μ => LinearMap.comp (Submodule.subtype (eigenspace f μ)) ((μ - μ₀) • LinearMap.id)) l

tactic: congr
state_before: case calc_2
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
g : End K V := f - ↑(algebraMap K (End K V)) μ₀
a : Π₀ (x : K), V := ↑(Dfinsupp.mapRange.linearMap fun μ => Submodule.subtype (eigenspace f μ)) l
⊢ ↑(↑(Dfinsupp.lsum ℕ) fun μ => LinearMap.comp (Submodule.subtype (eigenspace f μ)) ((μ - μ₀) • LinearMap.id)) l =
    ↑(↑(Dfinsupp.lsum ℕ) fun μ => LinearMap.comp g (Submodule.subtype (eigenspace f μ))) l

tactic: ext (μ v)
state_before: case calc_2.e_a.h.e_6.h
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
g : End K V := f - ↑(algebraMap K (End K V)) μ₀
a : Π₀ (x : K), V := ↑(Dfinsupp.mapRange.linearMap fun μ => Submodule.subtype (eigenspace f μ)) l
⊢ (fun μ => LinearMap.comp (Submodule.subtype (eigenspace f μ)) ((μ - μ₀) • LinearMap.id)) = fun μ =>
    LinearMap.comp g (Submodule.subtype (eigenspace f μ))

tactic: simp only [LinearMap.coe_comp, Function.comp_apply, LinearMap.smul_apply, LinearMap.id_coe,
  id.def, sub_smul, Submodule.subtype_apply, Submodule.coe_sub, Submodule.coe_smul_of_tower,
  LinearMap.sub_apply, mem_eigenspace_iff.1 v.prop, algebraMap_end_apply]
state_before: case calc_2.e_a.h.e_6.h.h.h
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
g : End K V := f - ↑(algebraMap K (End K V)) μ₀
a : Π₀ (x : K), V := ↑(Dfinsupp.mapRange.linearMap fun μ => Submodule.subtype (eigenspace f μ)) l
μ : K
v : { x // x ∈ eigenspace f μ }
⊢ ↑(LinearMap.comp (Submodule.subtype (eigenspace f μ)) ((μ - μ₀) • LinearMap.id)) v =
    ↑(LinearMap.comp g (Submodule.subtype (eigenspace f μ))) v

tactic: rw [Dfinsupp.sum_mapRange_index.linearMap]
state_before: case calc_3
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
g : End K V := f - ↑(algebraMap K (End K V)) μ₀
a : Π₀ (x : K), V := ↑(Dfinsupp.mapRange.linearMap fun μ => Submodule.subtype (eigenspace f μ)) l
⊢ ↑(↑(Dfinsupp.lsum ℕ) fun μ => LinearMap.comp g (Submodule.subtype (eigenspace f μ))) l =
    ↑(↑(Dfinsupp.lsum ℕ) fun x => g) a

tactic: simp only [Dfinsupp.sumAddHom_apply, LinearMap.id_coe, LinearMap.map_dfinsupp_sum, id.def,
  LinearMap.toAddMonoidHom_coe, Dfinsupp.lsum_apply_apply]
state_before: case calc_4
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
g : End K V := f - ↑(algebraMap K (End K V)) μ₀
a : Π₀ (x : K), V := ↑(Dfinsupp.mapRange.linearMap fun μ => Submodule.subtype (eigenspace f μ)) l
⊢ ↑(↑(Dfinsupp.lsum ℕ) fun x => g) a = ↑g (↑(↑(Dfinsupp.lsum ℕ) fun x => LinearMap.id) a)

tactic: simp only [Dfinsupp.sum_mapRange_index.linearMap, LinearMap.id_comp]
state_before: case calc_5
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
g : End K V := f - ↑(algebraMap K (End K V)) μ₀
a : Π₀ (x : K), V := ↑(Dfinsupp.mapRange.linearMap fun μ => Submodule.subtype (eigenspace f μ)) l
⊢ ↑g (↑(↑(Dfinsupp.lsum ℕ) fun x => LinearMap.id) a) = ↑g (↑S l)

tactic: intro μ
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
⊢ ∀ (μ : K), (μ - μ₀) • ↑l μ = 0

tactic: calc
  (μ - μ₀) • l μ = l' μ := by
    simp only [LinearMap.id_coe, id.def, LinearMap.smul_apply, Dfinsupp.mapRange_apply,
      Dfinsupp.mapRange.linearMap_apply]
  _ = 0 := by rw [l'_eq_0]; rfl
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
μ : K
⊢ (μ - μ₀) • ↑l μ = 0

tactic: simp only [LinearMap.id_coe, id.def, LinearMap.smul_apply, Dfinsupp.mapRange_apply,
  Dfinsupp.mapRange.linearMap_apply]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
μ : K
⊢ (μ - μ₀) • ↑l μ = ↑l' μ

tactic: rw [l'_eq_0]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
μ : K
⊢ ↑l' μ = 0

tactic: rfl
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
μ : K
⊢ ↑0 μ = 0

tactic: intro μ hμ
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
h_smul_eq_0 : ∀ (μ : K), (μ - μ₀) • ↑l μ = 0
⊢ ∀ (μ : K), μ ≠ μ₀ → ↑l μ = 0

tactic: apply or_iff_not_imp_left.1 (smul_eq_zero.1 (h_smul_eq_0 μ))
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
h_smul_eq_0 : ∀ (μ : K), (μ - μ₀) • ↑l μ = 0
μ : K
hμ : μ ≠ μ₀
⊢ ↑l μ = 0

tactic: rwa [sub_eq_zero]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
h_smul_eq_0 : ∀ (μ : K), (μ - μ₀) • ↑l μ = 0
μ : K
hμ : μ ≠ μ₀
⊢ ¬μ - μ₀ = 0

tactic: rw [← Finset.sum_const_zero]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
h_smul_eq_0 : ∀ (μ : K), (μ - μ₀) • ↑l μ = 0
h_lμ_eq_0 : ∀ (μ : K), μ ≠ μ₀ → ↑l μ = 0
⊢ (Finset.sum l_support' fun μ => ↑(↑l μ)) = 0

tactic: apply Finset.sum_congr rfl
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
h_smul_eq_0 : ∀ (μ : K), (μ - μ₀) • ↑l μ = 0
h_lμ_eq_0 : ∀ (μ : K), μ ≠ μ₀ → ↑l μ = 0
⊢ (Finset.sum l_support' fun μ => ↑(↑l μ)) = Finset.sum ?m.327909 fun _x => 0

K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
h_smul_eq_0 : ∀ (μ : K), (μ - μ₀) • ↑l μ = 0
h_lμ_eq_0 : ∀ (μ : K), μ ≠ μ₀ → ↑l μ = 0
⊢ Type ?u.327905

K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
h_smul_eq_0 : ∀ (μ : K), (μ - μ₀) • ↑l μ = 0
h_lμ_eq_0 : ∀ (μ : K), μ ≠ μ₀ → ↑l μ = 0
⊢ Finset ?m.327908

tactic: intro μ hμ
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
h_smul_eq_0 : ∀ (μ : K), (μ - μ₀) • ↑l μ = 0
h_lμ_eq_0 : ∀ (μ : K), μ ≠ μ₀ → ↑l μ = 0
⊢ ∀ (x : K), x ∈ l_support' → ↑(↑l x) = 0

tactic: rw [Submodule.coe_eq_zero, h_lμ_eq_0]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
h_smul_eq_0 : ∀ (μ : K), (μ - μ₀) • ↑l μ = 0
h_lμ_eq_0 : ∀ (μ : K), μ ≠ μ₀ → ↑l μ = 0
μ : K
hμ : μ ∈ l_support'
⊢ ↑(↑l μ) = 0

tactic: rintro rfl
state_before: case a
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
h_smul_eq_0 : ∀ (μ : K), (μ - μ₀) • ↑l μ = 0
h_lμ_eq_0 : ∀ (μ : K), μ ≠ μ₀ → ↑l μ = 0
μ : K
hμ : μ ∈ l_support'
⊢ μ ≠ μ₀

tactic: exact hμ₀ hμ
state_before: case a
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
l_support' : Finset K
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
μ : K
hμ : μ ∈ l_support'
hμ₀ : ¬μ ∈ l_support'
h_l_support : Dfinsupp.support l = insert μ l_support'
l' : Π₀ (i : K), { x // x ∈ eigenspace f i } := ↑(Dfinsupp.mapRange.linearMap fun μ_1 => (μ_1 - μ) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
h_smul_eq_0 : ∀ (μ_1 : K), (μ_1 - μ) • ↑l μ_1 = 0
h_lμ_eq_0 : ∀ (μ_1 : K), μ_1 ≠ μ → ↑l μ_1 = 0
⊢ False

tactic: simp only [Dfinsupp.lsum_apply_apply, Dfinsupp.sumAddHom_apply,
  LinearMap.toAddMonoidHom_coe, Dfinsupp.sum, h_l_support, Submodule.subtype_apply,
  Submodule.coe_eq_zero, Finset.sum_insert hμ₀, h_sum_l_support'_eq_0, add_zero] at hl
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
h_smul_eq_0 : ∀ (μ : K), (μ - μ₀) • ↑l μ = 0
h_lμ_eq_0 : ∀ (μ : K), μ ≠ μ₀ → ↑l μ = 0
h_sum_l_support'_eq_0 : (Finset.sum l_support' fun μ => ↑(↑l μ)) = 0
⊢ ↑l μ₀ = 0

tactic: exact hl
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
h_smul_eq_0 : ∀ (μ : K), (μ - μ₀) • ↑l μ = 0
h_lμ_eq_0 : ∀ (μ : K), μ ≠ μ₀ → ↑l μ = 0
h_sum_l_support'_eq_0 : (Finset.sum l_support' fun μ => ↑(↑l μ)) = 0
hl : ↑l μ₀ = 0
⊢ ↑l μ₀ = 0

tactic: ext μ
state_before: case insert
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
h_smul_eq_0 : ∀ (μ : K), (μ - μ₀) • ↑l μ = 0
h_lμ_eq_0 : ∀ (μ : K), μ ≠ μ₀ → ↑l μ = 0
h_sum_l_support'_eq_0 : (Finset.sum l_support' fun μ => ↑(↑l μ)) = 0
this : ↑l μ₀ = 0
⊢ l = 0

tactic: by_cases h_cases : μ = μ₀
state_before: case insert.h.a
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
h_smul_eq_0 : ∀ (μ : K), (μ - μ₀) • ↑l μ = 0
h_lμ_eq_0 : ∀ (μ : K), μ ≠ μ₀ → ↑l μ = 0
h_sum_l_support'_eq_0 : (Finset.sum l_support' fun μ => ↑(↑l μ)) = 0
this : ↑l μ₀ = 0
μ : K
⊢ ↑(↑l μ) = ↑(↑0 μ)

tactic: rwa [h_cases, SetLike.coe_eq_coe, Dfinsupp.coe_zero, Pi.zero_apply]
state_before: case pos
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
h_smul_eq_0 : ∀ (μ : K), (μ - μ₀) • ↑l μ = 0
h_lμ_eq_0 : ∀ (μ : K), μ ≠ μ₀ → ↑l μ = 0
h_sum_l_support'_eq_0 : (Finset.sum l_support' fun μ => ↑(↑l μ)) = 0
this : ↑l μ₀ = 0
μ : K
h_cases : μ = μ₀
⊢ ↑(↑l μ) = ↑(↑0 μ)

tactic: exact congr_arg _ (h_lμ_eq_0 μ h_cases)
state_before: case neg
K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
S : (Π₀ (μ : K), { x // x ∈ eigenspace f μ }) →ₗ[K] V := ↑(Dfinsupp.lsum ℕ) fun μ => Submodule.subtype (eigenspace f μ)
l✝ : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl✝ : ↑S l✝ = 0
x✝ : Finset K
h_l_support✝ : Dfinsupp.support l✝ = x✝
μ₀ : K
l_support' : Finset K
hμ₀ : ¬μ₀ ∈ l_support'
ih : ∀ (l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }), ↑S l = 0 → Dfinsupp.support l = l_support' → l = 0
l : Π₀ (μ : K), { x // x ∈ eigenspace f μ }
hl : ↑S l = 0
h_l_support : Dfinsupp.support l = insert μ₀ l_support'
l' : (fun x => Π₀ (i : K), { x // x ∈ eigenspace f i }) l :=
  ↑(Dfinsupp.mapRange.linearMap fun μ => (μ - μ₀) • LinearMap.id) l
h_l_support' : Dfinsupp.support l' = l_support'
total_l' : ↑S l' = 0
l'_eq_0 : l' = 0
h_smul_eq_0 : ∀ (μ : K), (μ - μ₀) • ↑l μ = 0
h_lμ_eq_0 : ∀ (μ : K), μ ≠ μ₀ → ↑l μ = 0
h_sum_l_support'_eq_0 : (Finset.sum l_support' fun μ => ↑(↑l μ)) = 0
this : ↑l μ₀ = 0
μ : K
h_cases : ¬μ = μ₀
⊢ ↑(↑l μ) = ↑(↑0 μ)