[GOAL]
K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : _root_.Finite K
inst✝ : FiniteDimensional K V
⊢ _root_.Finite V
[PROOFSTEP]
cases nonempty_fintype K
[GOAL]
case intro
K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : _root_.Finite K
inst✝ : FiniteDimensional K V
val✝ : Fintype K
⊢ _root_.Finite V
[PROOFSTEP]
haveI := fintypeOfFintype K V
[GOAL]
case intro
K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : _root_.Finite K
inst✝ : FiniteDimensional K V
val✝ : Fintype K
this : Fintype V
⊢ _root_.Finite V
[PROOFSTEP]
infer_instance
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inst✝ : _root_.Finite ι
h : Basis ι K V
⊢ FiniteDimensional K V
[PROOFSTEP]
classical
cases nonempty_fintype ι
exact
  ⟨⟨Finset.univ.image h, by
      convert h.span_eq
      simp⟩⟩
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inst✝ : _root_.Finite ι
h : Basis ι K V
⊢ FiniteDimensional K V
[PROOFSTEP]
cases nonempty_fintype ι
[GOAL]
case intro
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inst✝ : _root_.Finite ι
h : Basis ι K V
val✝ : Fintype ι
⊢ FiniteDimensional K V
[PROOFSTEP]
exact
  ⟨⟨Finset.univ.image h, by
      convert h.span_eq
      simp⟩⟩
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inst✝ : _root_.Finite ι
h : Basis ι K V
val✝ : Fintype ι
⊢ span K ↑(Finset.image (↑h) Finset.univ) = ⊤
[PROOFSTEP]
convert h.span_eq
[GOAL]
case h.e'_2.h.e'_6
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inst✝ : _root_.Finite ι
h : Basis ι K V
val✝ : Fintype ι
⊢ ↑(Finset.image (↑h) Finset.univ) = Set.range ↑h
[PROOFSTEP]
simp
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
⊢ Fintype ↑(Basis.ofVectorSpaceIndex K V)
[PROOFSTEP]
letI : IsNoetherian K V := IsNoetherian.iff_fg.2 inferInstance
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
this : IsNoetherian K V := Iff.mpr iff_fg inferInstance
⊢ Fintype ↑(Basis.ofVectorSpaceIndex K V)
[PROOFSTEP]
infer_instance
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
S : Submodule K V
⊢ FiniteDimensional K { x // x ∈ S }
[PROOFSTEP]
letI : IsNoetherian K V := iff_fg.2 ?_
[GOAL]
case refine_2
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
S : Submodule K V
this : IsNoetherian K V := Iff.mpr iff_fg ?refine_1
⊢ FiniteDimensional K { x // x ∈ S }
case refine_1
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
S : Submodule K V
⊢ Module.Finite K V
[PROOFSTEP]
exact iff_fg.1 (IsNoetherian.iff_rank_lt_aleph0.2 (lt_of_le_of_lt (rank_submodule_le _) (rank_lt_aleph0 K V)))
[GOAL]
case refine_1
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
S : Submodule K V
⊢ Module.Finite K V
[PROOFSTEP]
infer_instance
[GOAL]
K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
h : 0 < finrank K V
⊢ FiniteDimensional K V
[PROOFSTEP]
contrapose h
[GOAL]
K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
h : ¬FiniteDimensional K V
⊢ ¬0 < finrank K V
[PROOFSTEP]
simp [finrank_of_infinite_dimensional h]
[GOAL]
K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
n : ℕ
hn : finrank K V = Nat.succ n
⊢ 0 < finrank K V
[PROOFSTEP]
rw [hn]
[GOAL]
K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
n : ℕ
hn : finrank K V = Nat.succ n
⊢ 0 < Nat.succ n
[PROOFSTEP]
exact n.succ_pos
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
n : ℕ
inst✝ : Fact (finrank K V = n + 1)
⊢ 0 < finrank K V
[PROOFSTEP]
convert Nat.succ_pos n
[GOAL]
case h.e'_4
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
n : ℕ
inst✝ : Fact (finrank K V = n + 1)
⊢ finrank K V = Nat.succ n
[PROOFSTEP]
apply Fact.out
[GOAL]
K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
W : Type v
inst✝¹ : AddCommGroup W
inst✝ : Module K W
n : ℕ
hn : n ≠ 0
hVW : Module.rank K V = n • Module.rank K W
⊢ FiniteDimensional K V ↔ FiniteDimensional K W
[PROOFSTEP]
simp only [FiniteDimensional, ← IsNoetherian.iff_fg, IsNoetherian.iff_rank_lt_aleph0, hVW,
  Cardinal.nsmul_lt_aleph0_iff_of_ne_zero hn]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
ι : Type w
h : Basis ι K V
⊢ ↑(finrank K V) = #ι
[PROOFSTEP]
haveI : IsNoetherian K V := iff_fg.2 inferInstance
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
ι : Type w
h : Basis ι K V
this : IsNoetherian K V
⊢ ↑(finrank K V) = #ι
[PROOFSTEP]
haveI : Fintype ι := fintypeBasisIndex h
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
ι : Type w
h : Basis ι K V
this✝ : IsNoetherian K V
this : Fintype ι
⊢ ↑(finrank K V) = #ι
[PROOFSTEP]
rw [Cardinal.mk_fintype, finrank_eq_card_basis h]
[GOAL]
K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
ι : Type u_1
b : Basis ι K K
⊢ Unique ι
[PROOFSTEP]
have A : Cardinal.mk ι = ↑(FiniteDimensional.finrank K K) := (FiniteDimensional.finrank_eq_card_basis' b).symm
[GOAL]
K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
ι : Type u_1
b : Basis ι K K
A : #ι = ↑(finrank K K)
⊢ Unique ι
[PROOFSTEP]
simp only [Cardinal.eq_one_iff_unique, FiniteDimensional.finrank_self, Nat.cast_one] at A 
[GOAL]
K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
ι : Type u_1
b : Basis ι K K
A : Subsingleton ι ∧ Nonempty ι
⊢ Unique ι
[PROOFSTEP]
exact Nonempty.some ((unique_iff_subsingleton_and_nonempty _).2 A)
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type u_1
inst✝ : Unique ι
h : finrank K V = 1
v : V
i : ι
hv : v = 0
⊢ ↑(↑(basisUnique ι h).repr v) i = 0
[PROOFSTEP]
rw [hv, LinearEquiv.map_zero, Finsupp.zero_apply]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
ι : Type w
b : ι → V
h : LinearIndependent K b
⊢ #ι ≤ ↑(finrank K V)
[PROOFSTEP]
rw [← lift_le.{max v w}]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
ι : Type w
b : ι → V
h : LinearIndependent K b
⊢ lift #ι ≤ lift ↑(finrank K V)
[PROOFSTEP]
simpa [← finrank_eq_rank', -finrank_eq_rank] using cardinal_lift_le_rank_of_linearIndependent h
[GOAL]
K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : FiniteDimensional K V
ι : Type u_1
inst✝ : Fintype ι
b : ι → V
h : LinearIndependent K b
⊢ Fintype.card ι ≤ finrank K V
[PROOFSTEP]
simpa using cardinal_mk_le_finrank_of_linearIndependent h
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
b : Finset V
h : LinearIndependent K fun x => ↑x
⊢ Finset.card b ≤ finrank K V
[PROOFSTEP]
rw [← Fintype.card_coe]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
b : Finset V
h : LinearIndependent K fun x => ↑x
⊢ Fintype.card { x // x ∈ b } ≤ finrank K V
[PROOFSTEP]
exact fintype_card_le_finrank_of_linearIndependent h
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inst✝ : FiniteDimensional K V
v : ι → V
h : LinearIndependent K v
⊢ #ι < ℵ₀
[PROOFSTEP]
apply Cardinal.lift_lt.1
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inst✝ : FiniteDimensional K V
v : ι → V
h : LinearIndependent K v
⊢ lift #ι < lift ℵ₀
[PROOFSTEP]
apply lt_of_le_of_lt
[GOAL]
case a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inst✝ : FiniteDimensional K V
v : ι → V
h : LinearIndependent K v
⊢ lift #ι ≤ ?b
case a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inst✝ : FiniteDimensional K V
v : ι → V
h : LinearIndependent K v
⊢ ?b < lift ℵ₀
case b
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inst✝ : FiniteDimensional K V
v : ι → V
h : LinearIndependent K v
⊢ Cardinal.{max w ?u.252424}
[PROOFSTEP]
apply cardinal_lift_le_rank_of_linearIndependent h
[GOAL]
case a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inst✝ : FiniteDimensional K V
v : ι → V
h : LinearIndependent K v
⊢ lift (Module.rank K V) < lift ℵ₀
[PROOFSTEP]
rw [← finrank_eq_rank, Cardinal.lift_aleph0, Cardinal.lift_natCast]
[GOAL]
case a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inst✝ : FiniteDimensional K V
v : ι → V
h : LinearIndependent K v
⊢ ↑(finrank K V) < ℵ₀
[PROOFSTEP]
apply Cardinal.nat_lt_aleph0
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inf : Infinite ι
inst✝ : FiniteDimensional K V
v : ι → V
⊢ ¬LinearIndependent K v
[PROOFSTEP]
intro h_lin_indep
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inf : Infinite ι
inst✝ : FiniteDimensional K V
v : ι → V
h_lin_indep : LinearIndependent K v
⊢ False
[PROOFSTEP]
have : ¬ℵ₀ ≤ #ι := not_le.mpr (lt_aleph0_of_linearIndependent h_lin_indep)
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inf : Infinite ι
inst✝ : FiniteDimensional K V
v : ι → V
h_lin_indep : LinearIndependent K v
this : ¬ℵ₀ ≤ #ι
⊢ False
[PROOFSTEP]
have : ℵ₀ ≤ #ι := infinite_iff.mp inf
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type w
inf : Infinite ι
inst✝ : FiniteDimensional K V
v : ι → V
h_lin_indep : LinearIndependent K v
this✝ : ¬ℵ₀ ≤ #ι
this : ℵ₀ ≤ #ι
⊢ False
[PROOFSTEP]
contradiction
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
⊢ 0 < finrank K V ↔ 0 < Module.rank K V
[PROOFSTEP]
rw [← finrank_eq_rank]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
⊢ 0 < finrank K V ↔ 0 < ↑(finrank K V)
[PROOFSTEP]
norm_cast
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
⊢ 0 < finrank K V ↔ 0 < Module.rank K V
[PROOFSTEP]
rw [← finrank_eq_rank]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
⊢ 0 < finrank K V ↔ 0 < ↑(finrank K V)
[PROOFSTEP]
norm_cast
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
⊢ finrank K V = 0 ↔ Module.rank K V = 0
[PROOFSTEP]
rw [← finrank_eq_rank]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
⊢ finrank K V = 0 ↔ ↑(finrank K V) = 0
[PROOFSTEP]
norm_cast
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
S : Submodule K V
h : finrank K { x // x ∈ S } = finrank K V
⊢ S = ⊤
[PROOFSTEP]
haveI : IsNoetherian K V := iff_fg.2 inferInstance
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
S : Submodule K V
h : finrank K { x // x ∈ S } = finrank K V
this : IsNoetherian K V
⊢ S = ⊤
[PROOFSTEP]
set bS := Basis.ofVectorSpace K S with bS_eq
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
S : Submodule K V
h : finrank K { x // x ∈ S } = finrank K V
this : IsNoetherian K V
bS : Basis (↑(Basis.ofVectorSpaceIndex K { x // x ∈ S })) K { x // x ∈ S } := Basis.ofVectorSpace K { x // x ∈ S }
bS_eq : bS = Basis.ofVectorSpace K { x // x ∈ S }
⊢ S = ⊤
[PROOFSTEP]
have : LinearIndependent K ((↑) : ((↑) '' Basis.ofVectorSpaceIndex K S : Set V) → V) :=
  @LinearIndependent.image_subtype _ _ _ _ _ _ _ _ _ (Submodule.subtype S) (by simpa using bS.linearIndependent)
    (by simp)
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
S : Submodule K V
h : finrank K { x // x ∈ S } = finrank K V
this : IsNoetherian K V
bS : Basis (↑(Basis.ofVectorSpaceIndex K { x // x ∈ S })) K { x // x ∈ S } := Basis.ofVectorSpace K { x // x ∈ S }
bS_eq : bS = Basis.ofVectorSpace K { x // x ∈ S }
⊢ LinearIndependent K fun x => ↑x
[PROOFSTEP]
simpa using bS.linearIndependent
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
S : Submodule K V
h : finrank K { x // x ∈ S } = finrank K V
this : IsNoetherian K V
bS : Basis (↑(Basis.ofVectorSpaceIndex K { x // x ∈ S })) K { x // x ∈ S } := Basis.ofVectorSpace K { x // x ∈ S }
bS_eq : bS = Basis.ofVectorSpace K { x // x ∈ S }
⊢ Disjoint (span K (Basis.ofVectorSpaceIndex K { x // x ∈ S })) (LinearMap.ker (Submodule.subtype S))
[PROOFSTEP]
simp
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
S : Submodule K V
h : finrank K { x // x ∈ S } = finrank K V
this✝ : IsNoetherian K V
bS : Basis (↑(Basis.ofVectorSpaceIndex K { x // x ∈ S })) K { x // x ∈ S } := Basis.ofVectorSpace K { x // x ∈ S }
bS_eq : bS = Basis.ofVectorSpace K { x // x ∈ S }
this : LinearIndependent K Subtype.val
⊢ S = ⊤
[PROOFSTEP]
set b := Basis.extend this with b_eq
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
S : Submodule K V
h : finrank K { x // x ∈ S } = finrank K V
this✝ : IsNoetherian K V
bS : Basis (↑(Basis.ofVectorSpaceIndex K { x // x ∈ S })) K { x // x ∈ S } := Basis.ofVectorSpace K { x // x ∈ S }
bS_eq : bS = Basis.ofVectorSpace K { x // x ∈ S }
this : LinearIndependent K Subtype.val
b : Basis (↑(LinearIndependent.extend this (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ))) K
  V :=
  Basis.extend this
b_eq : b = Basis.extend this
⊢ S = ⊤
[PROOFSTEP]
letI i1 : Fintype (this.extend _) := (finite_of_linearIndependent (by simpa using b.linearIndependent)).fintype
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
S : Submodule K V
h : finrank K { x // x ∈ S } = finrank K V
this✝ : IsNoetherian K V
bS : Basis (↑(Basis.ofVectorSpaceIndex K { x // x ∈ S })) K { x // x ∈ S } := Basis.ofVectorSpace K { x // x ∈ S }
bS_eq : bS = Basis.ofVectorSpace K { x // x ∈ S }
this : LinearIndependent K Subtype.val
b : Basis (↑(LinearIndependent.extend this (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ))) K
  V :=
  Basis.extend this
b_eq : b = Basis.extend this
⊢ LinearIndependent ?m.281540 Subtype.val
[PROOFSTEP]
simpa using b.linearIndependent
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
S : Submodule K V
h : finrank K { x // x ∈ S } = finrank K V
this✝ : IsNoetherian K V
bS : Basis (↑(Basis.ofVectorSpaceIndex K { x // x ∈ S })) K { x // x ∈ S } := Basis.ofVectorSpace K { x // x ∈ S }
bS_eq : bS = Basis.ofVectorSpace K { x // x ∈ S }
this : LinearIndependent K Subtype.val
b : Basis (↑(LinearIndependent.extend this (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ))) K
  V :=
  Basis.extend this
b_eq : b = Basis.extend this
i1 : Fintype
  ↑(LinearIndependent.extend this (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)) :=
  Set.Finite.fintype
    (_ :
      Set.Finite
        (LinearIndependent.extend this (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)))
⊢ S = ⊤
[PROOFSTEP]
letI i2 : Fintype (((↑) : S → V) '' Basis.ofVectorSpaceIndex K S) := (finite_of_linearIndependent this).fintype
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
S : Submodule K V
h : finrank K { x // x ∈ S } = finrank K V
this✝ : IsNoetherian K V
bS : Basis (↑(Basis.ofVectorSpaceIndex K { x // x ∈ S })) K { x // x ∈ S } := Basis.ofVectorSpace K { x // x ∈ S }
bS_eq : bS = Basis.ofVectorSpace K { x // x ∈ S }
this : LinearIndependent K Subtype.val
b : Basis (↑(LinearIndependent.extend this (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ))) K
  V :=
  Basis.extend this
b_eq : b = Basis.extend this
i1 : Fintype
  ↑(LinearIndependent.extend this (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)) :=
  Set.Finite.fintype
    (_ :
      Set.Finite
        (LinearIndependent.extend this (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)))
i2 : Fintype ↑(Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S }) :=
  Set.Finite.fintype (_ : Set.Finite (Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S }))
⊢ S = ⊤
[PROOFSTEP]
letI i3 : Fintype (Basis.ofVectorSpaceIndex K S) :=
  (finite_of_linearIndependent (by simpa using bS.linearIndependent)).fintype
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
S : Submodule K V
h : finrank K { x // x ∈ S } = finrank K V
this✝ : IsNoetherian K V
bS : Basis (↑(Basis.ofVectorSpaceIndex K { x // x ∈ S })) K { x // x ∈ S } := Basis.ofVectorSpace K { x // x ∈ S }
bS_eq : bS = Basis.ofVectorSpace K { x // x ∈ S }
this : LinearIndependent K Subtype.val
b : Basis (↑(LinearIndependent.extend this (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ))) K
  V :=
  Basis.extend this
b_eq : b = Basis.extend this
i1 : Fintype
  ↑(LinearIndependent.extend this (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)) :=
  Set.Finite.fintype
    (_ :
      Set.Finite
        (LinearIndependent.extend this (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)))
i2 : Fintype ↑(Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S }) :=
  Set.Finite.fintype (_ : Set.Finite (Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S }))
⊢ LinearIndependent ?m.287044 Subtype.val
[PROOFSTEP]
simpa using bS.linearIndependent
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
S : Submodule K V
h : finrank K { x // x ∈ S } = finrank K V
this✝ : IsNoetherian K V
bS : Basis (↑(Basis.ofVectorSpaceIndex K { x // x ∈ S })) K { x // x ∈ S } := Basis.ofVectorSpace K { x // x ∈ S }
bS_eq : bS = Basis.ofVectorSpace K { x // x ∈ S }
this : LinearIndependent K Subtype.val
b : Basis (↑(LinearIndependent.extend this (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ))) K
  V :=
  Basis.extend this
b_eq : b = Basis.extend this
i1 : Fintype
  ↑(LinearIndependent.extend this (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)) :=
  Set.Finite.fintype
    (_ :
      Set.Finite
        (LinearIndependent.extend this (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)))
i2 : Fintype ↑(Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S }) :=
  Set.Finite.fintype (_ : Set.Finite (Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S }))
i3 : Fintype ↑(Basis.ofVectorSpaceIndex K { x // x ∈ S }) :=
  Set.Finite.fintype (_ : Set.Finite (Basis.ofVectorSpaceIndex K { x // x ∈ S }))
⊢ S = ⊤
[PROOFSTEP]
have : (↑) '' Basis.ofVectorSpaceIndex K S = this.extend (Set.subset_univ _) :=
  Set.eq_of_subset_of_card_le (this.subset_extend _)
    (by
      rw [Set.card_image_of_injective _ Subtype.coe_injective, ← finrank_eq_card_basis bS, ← finrank_eq_card_basis b,
        h])
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
S : Submodule K V
h : finrank K { x // x ∈ S } = finrank K V
this✝ : IsNoetherian K V
bS : Basis (↑(Basis.ofVectorSpaceIndex K { x // x ∈ S })) K { x // x ∈ S } := Basis.ofVectorSpace K { x // x ∈ S }
bS_eq : bS = Basis.ofVectorSpace K { x // x ∈ S }
this : LinearIndependent K Subtype.val
b : Basis (↑(LinearIndependent.extend this (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ))) K
  V :=
  Basis.extend this
b_eq : b = Basis.extend this
i1 : Fintype
  ↑(LinearIndependent.extend this (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)) :=
  Set.Finite.fintype
    (_ :
      Set.Finite
        (LinearIndependent.extend this (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)))
i2 : Fintype ↑(Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S }) :=
  Set.Finite.fintype (_ : Set.Finite (Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S }))
i3 : Fintype ↑(Basis.ofVectorSpaceIndex K { x // x ∈ S }) :=
  Set.Finite.fintype (_ : Set.Finite (Basis.ofVectorSpaceIndex K { x // x ∈ S }))
⊢ Fintype.card
      ↑(LinearIndependent.extend this (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)) ≤
    Fintype.card ↑(Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S })
[PROOFSTEP]
rw [Set.card_image_of_injective _ Subtype.coe_injective, ← finrank_eq_card_basis bS, ← finrank_eq_card_basis b, h]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
S : Submodule K V
h : finrank K { x // x ∈ S } = finrank K V
this✝¹ : IsNoetherian K V
bS : Basis (↑(Basis.ofVectorSpaceIndex K { x // x ∈ S })) K { x // x ∈ S } := Basis.ofVectorSpace K { x // x ∈ S }
bS_eq : bS = Basis.ofVectorSpace K { x // x ∈ S }
this✝ : LinearIndependent K Subtype.val
b : Basis (↑(LinearIndependent.extend this✝ (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)))
  K V :=
  Basis.extend this✝
b_eq : b = Basis.extend this✝
i1 : Fintype
  ↑(LinearIndependent.extend this✝ (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)) :=
  Set.Finite.fintype
    (_ :
      Set.Finite
        (LinearIndependent.extend this✝ (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)))
i2 : Fintype ↑(Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S }) :=
  Set.Finite.fintype (_ : Set.Finite (Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S }))
i3 : Fintype ↑(Basis.ofVectorSpaceIndex K { x // x ∈ S }) :=
  Set.Finite.fintype (_ : Set.Finite (Basis.ofVectorSpaceIndex K { x // x ∈ S }))
this :
  Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } =
    LinearIndependent.extend this✝ (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)
⊢ S = ⊤
[PROOFSTEP]
rw [← b.span_eq, b_eq, Basis.coe_extend, Subtype.range_coe, ← this, ← Submodule.coeSubtype, span_image]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
S : Submodule K V
h : finrank K { x // x ∈ S } = finrank K V
this✝¹ : IsNoetherian K V
bS : Basis (↑(Basis.ofVectorSpaceIndex K { x // x ∈ S })) K { x // x ∈ S } := Basis.ofVectorSpace K { x // x ∈ S }
bS_eq : bS = Basis.ofVectorSpace K { x // x ∈ S }
this✝ : LinearIndependent K Subtype.val
b : Basis (↑(LinearIndependent.extend this✝ (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)))
  K V :=
  Basis.extend this✝
b_eq : b = Basis.extend this✝
i1 : Fintype
  ↑(LinearIndependent.extend this✝ (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)) :=
  Set.Finite.fintype
    (_ :
      Set.Finite
        (LinearIndependent.extend this✝ (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)))
i2 : Fintype ↑(Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S }) :=
  Set.Finite.fintype (_ : Set.Finite (Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S }))
i3 : Fintype ↑(Basis.ofVectorSpaceIndex K { x // x ∈ S }) :=
  Set.Finite.fintype (_ : Set.Finite (Basis.ofVectorSpaceIndex K { x // x ∈ S }))
this :
  Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } =
    LinearIndependent.extend this✝ (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)
⊢ S = Submodule.map (Submodule.subtype S) (span K (Basis.ofVectorSpaceIndex K { x // x ∈ S }))
[PROOFSTEP]
have := bS.span_eq
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
S : Submodule K V
h : finrank K { x // x ∈ S } = finrank K V
this✝² : IsNoetherian K V
bS : Basis (↑(Basis.ofVectorSpaceIndex K { x // x ∈ S })) K { x // x ∈ S } := Basis.ofVectorSpace K { x // x ∈ S }
bS_eq : bS = Basis.ofVectorSpace K { x // x ∈ S }
this✝¹ : LinearIndependent K Subtype.val
b : Basis (↑(LinearIndependent.extend this✝¹ (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)))
  K V :=
  Basis.extend this✝¹
b_eq : b = Basis.extend this✝¹
i1 : Fintype
  ↑(LinearIndependent.extend this✝¹ (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)) :=
  Set.Finite.fintype
    (_ :
      Set.Finite
        (LinearIndependent.extend this✝¹ (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)))
i2 : Fintype ↑(Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S }) :=
  Set.Finite.fintype (_ : Set.Finite (Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S }))
i3 : Fintype ↑(Basis.ofVectorSpaceIndex K { x // x ∈ S }) :=
  Set.Finite.fintype (_ : Set.Finite (Basis.ofVectorSpaceIndex K { x // x ∈ S }))
this✝ :
  Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } =
    LinearIndependent.extend this✝¹ (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)
this : span K (Set.range ↑bS) = ⊤
⊢ S = Submodule.map (Submodule.subtype S) (span K (Basis.ofVectorSpaceIndex K { x // x ∈ S }))
[PROOFSTEP]
rw [bS_eq, Basis.coe_ofVectorSpace, Subtype.range_coe] at this 
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
S : Submodule K V
h : finrank K { x // x ∈ S } = finrank K V
this✝² : IsNoetherian K V
bS : Basis (↑(Basis.ofVectorSpaceIndex K { x // x ∈ S })) K { x // x ∈ S } := Basis.ofVectorSpace K { x // x ∈ S }
bS_eq : bS = Basis.ofVectorSpace K { x // x ∈ S }
this✝¹ : LinearIndependent K Subtype.val
b : Basis (↑(LinearIndependent.extend this✝¹ (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)))
  K V :=
  Basis.extend this✝¹
b_eq : b = Basis.extend this✝¹
i1 : Fintype
  ↑(LinearIndependent.extend this✝¹ (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)) :=
  Set.Finite.fintype
    (_ :
      Set.Finite
        (LinearIndependent.extend this✝¹ (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)))
i2 : Fintype ↑(Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S }) :=
  Set.Finite.fintype (_ : Set.Finite (Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S }))
i3 : Fintype ↑(Basis.ofVectorSpaceIndex K { x // x ∈ S }) :=
  Set.Finite.fintype (_ : Set.Finite (Basis.ofVectorSpaceIndex K { x // x ∈ S }))
this✝ :
  Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } =
    LinearIndependent.extend this✝¹ (_ : Subtype.val '' Basis.ofVectorSpaceIndex K { x // x ∈ S } ⊆ Set.univ)
this : span K (Basis.ofVectorSpaceIndex K { x // x ∈ S }) = ⊤
⊢ S = Submodule.map (Submodule.subtype S) (span K (Basis.ofVectorSpaceIndex K { x // x ∈ S }))
[PROOFSTEP]
rw [this, map_top (Submodule.subtype S), range_subtype]
[GOAL]
K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
⊢ FiniteDimensional K K
[PROOFSTEP]
infer_instance
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
ι : Type w
p : ι → Submodule K V
hp : CompleteLattice.Independent p
⊢ #{ i // p i ≠ ⊥ } ≤ ↑(finrank K V)
[PROOFSTEP]
suffices Cardinal.lift.{v} #{ i // p i ≠ ⊥ } ≤ Cardinal.lift.{v} (finrank K V : Cardinal.{w}) by
  rwa [Cardinal.lift_le] at this 
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
ι : Type w
p : ι → Submodule K V
hp : CompleteLattice.Independent p
this : lift #{ i // p i ≠ ⊥ } ≤ lift ↑(finrank K V)
⊢ #{ i // p i ≠ ⊥ } ≤ ↑(finrank K V)
[PROOFSTEP]
rwa [Cardinal.lift_le] at this 
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
ι : Type w
p : ι → Submodule K V
hp : CompleteLattice.Independent p
⊢ lift #{ i // p i ≠ ⊥ } ≤ lift ↑(finrank K V)
[PROOFSTEP]
calc
  Cardinal.lift.{v} #{ i // p i ≠ ⊥ } ≤ Cardinal.lift.{w} (Module.rank K V) := hp.subtype_ne_bot_le_rank
  _ = Cardinal.lift.{w} (finrank K V : Cardinal.{v}) := by rw [finrank_eq_rank]
  _ = Cardinal.lift.{v} (finrank K V : Cardinal.{w}) := by simp
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
ι : Type w
p : ι → Submodule K V
hp : CompleteLattice.Independent p
⊢ lift (Module.rank K V) = lift ↑(finrank K V)
[PROOFSTEP]
rw [finrank_eq_rank]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
ι : Type w
p : ι → Submodule K V
hp : CompleteLattice.Independent p
⊢ lift ↑(finrank K V) = lift ↑(finrank K V)
[PROOFSTEP]
simp
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
ι : Type w
p : ι → Submodule K V
hp : CompleteLattice.Independent p
⊢ Fintype { i // p i ≠ ⊥ }
[PROOFSTEP]
suffices #{ i // p i ≠ ⊥ } < (ℵ₀ : Cardinal.{w})
  by
  rw [Cardinal.lt_aleph0_iff_fintype] at this 
  exact this.some
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
ι : Type w
p : ι → Submodule K V
hp : CompleteLattice.Independent p
this : #{ i // p i ≠ ⊥ } < ℵ₀
⊢ Fintype { i // p i ≠ ⊥ }
[PROOFSTEP]
rw [Cardinal.lt_aleph0_iff_fintype] at this 
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
ι : Type w
p : ι → Submodule K V
hp : CompleteLattice.Independent p
this : Nonempty (Fintype { i // p i ≠ ⊥ })
⊢ Fintype { i // p i ≠ ⊥ }
[PROOFSTEP]
exact this.some
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
ι : Type w
p : ι → Submodule K V
hp : CompleteLattice.Independent p
⊢ #{ i // p i ≠ ⊥ } < ℵ₀
[PROOFSTEP]
refine' lt_of_le_of_lt hp.subtype_ne_bot_le_finrank_aux _
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
ι : Type w
p : ι → Submodule K V
hp : CompleteLattice.Independent p
⊢ ↑(finrank K V) < ℵ₀
[PROOFSTEP]
simp [Cardinal.nat_lt_aleph0]
[GOAL]
K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : FiniteDimensional K V
ι : Type w
p : ι → Submodule K V
hp : CompleteLattice.Independent p
inst✝ : Fintype { i // p i ≠ ⊥ }
⊢ Fintype.card { i // p i ≠ ⊥ } ≤ finrank K V
[PROOFSTEP]
simpa using hp.subtype_ne_bot_le_finrank_aux
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
⊢ ∃ f, ∑ e in t, f e • e = 0 ∧ ∃ x, x ∈ t ∧ f x ≠ 0
[PROOFSTEP]
classical
have := mt finset_card_le_finrank_of_linearIndependent (by simpa using h)
rw [not_linearIndependent_iff] at this 
obtain ⟨s, g, sum, z, zm, nonzero⟩ := this
let f : V → K := fun x =>
  if h : x ∈ t then if (⟨x, h⟩ : t) ∈ s then g ⟨x, h⟩ else 0
  else
    0
      -- and finally clean up the mess caused by the extension.
refine' ⟨f, _, _⟩
· dsimp
  rw [← (sum)]
    -- porting note: need parens to disambiguate
  fapply sum_bij_ne_zero fun v hvt _ => (⟨v, hvt⟩ : { v // v ∈ t })
  · intro v hvt H
    dsimp
    rw [dif_pos hvt] at H 
    contrapose! H
    rw [if_neg H, zero_smul]
  · intro _ _ _ _ _ _
    exact Subtype.mk.inj
  · intro b hbs hb
    use b
    simpa only [hbs, exists_prop, dif_pos, Finset.mk_coe, and_true_iff, if_true, Finset.coe_mem, eq_self_iff_true,
      exists_prop_of_true, Ne.def] using hb
  · intro a h₁
    dsimp
    rw [dif_pos h₁]
    intro h₂
    rw [if_pos]
    contrapose! h₂
    rw [if_neg h₂, zero_smul]
· refine' ⟨z, z.2, _⟩
  dsimp only
  erw [dif_pos z.2, if_pos] <;> rwa [Subtype.coe_eta]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
⊢ ∃ f, ∑ e in t, f e • e = 0 ∧ ∃ x, x ∈ t ∧ f x ≠ 0
[PROOFSTEP]
have := mt finset_card_le_finrank_of_linearIndependent (by simpa using h)
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
⊢ ¬card ?m.337366 ≤ finrank ?m.337360 ?m.337361
[PROOFSTEP]
simpa using h
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
this : ¬LinearIndependent K fun x => ↑x
⊢ ∃ f, ∑ e in t, f e • e = 0 ∧ ∃ x, x ∈ t ∧ f x ≠ 0
[PROOFSTEP]
rw [not_linearIndependent_iff] at this 
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
this : ∃ s g, ∑ i in s, g i • ↑i = 0 ∧ ∃ i, i ∈ s ∧ g i ≠ 0
⊢ ∃ f, ∑ e in t, f e • e = 0 ∧ ∃ x, x ∈ t ∧ f x ≠ 0
[PROOFSTEP]
obtain ⟨s, g, sum, z, zm, nonzero⟩ := this
[GOAL]
case intro.intro.intro.intro.intro
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
⊢ ∃ f, ∑ e in t, f e • e = 0 ∧ ∃ x, x ∈ t ∧ f x ≠ 0
[PROOFSTEP]
let f : V → K := fun x =>
  if h : x ∈ t then if (⟨x, h⟩ : t) ∈ s then g ⟨x, h⟩ else 0
  else
    0
      -- and finally clean up the mess caused by the extension.
[GOAL]
case intro.intro.intro.intro.intro
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
⊢ ∃ f, ∑ e in t, f e • e = 0 ∧ ∃ x, x ∈ t ∧ f x ≠ 0
[PROOFSTEP]
refine' ⟨f, _, _⟩
[GOAL]
case intro.intro.intro.intro.intro.refine'_1
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
⊢ ∑ e in t, f e • e = 0
[PROOFSTEP]
dsimp
[GOAL]
case intro.intro.intro.intro.intro.refine'_1
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
⊢ ∑ e in t,
      (if h : e ∈ t then if { val := e, property := h } ∈ s then g { val := e, property := h } else 0 else 0) • e =
    0
[PROOFSTEP]
rw [← (sum)]
  -- porting note: need parens to disambiguate
[GOAL]
case intro.intro.intro.intro.intro.refine'_1
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
⊢ ∑ e in t,
      (if h : e ∈ t then if { val := e, property := h } ∈ s then g { val := e, property := h } else 0 else 0) • e =
    ∑ i in s, g i • ↑i
[PROOFSTEP]
fapply sum_bij_ne_zero fun v hvt _ => (⟨v, hvt⟩ : { v // v ∈ t })
[GOAL]
case intro.intro.intro.intro.intro.refine'_1.hi
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
⊢ ∀ (a : V) (h₁ : a ∈ t),
    (if h : a ∈ t then if { val := a, property := h } ∈ s then g { val := a, property := h } else 0 else 0) • a ≠ 0 →
      { val := a, property := h₁ } ∈ s
[PROOFSTEP]
intro v hvt H
[GOAL]
case intro.intro.intro.intro.intro.refine'_1.hi
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
v : V
hvt : v ∈ t
H : (if h : v ∈ t then if { val := v, property := h } ∈ s then g { val := v, property := h } else 0 else 0) • v ≠ 0
⊢ { val := v, property := hvt } ∈ s
[PROOFSTEP]
dsimp
[GOAL]
case intro.intro.intro.intro.intro.refine'_1.hi
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
v : V
hvt : v ∈ t
H : (if h : v ∈ t then if { val := v, property := h } ∈ s then g { val := v, property := h } else 0 else 0) • v ≠ 0
⊢ { val := v, property := hvt } ∈ s
[PROOFSTEP]
rw [dif_pos hvt] at H 
[GOAL]
case intro.intro.intro.intro.intro.refine'_1.hi
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
v : V
hvt : v ∈ t
H : (if { val := v, property := hvt } ∈ s then g { val := v, property := hvt } else 0) • v ≠ 0
⊢ { val := v, property := hvt } ∈ s
[PROOFSTEP]
contrapose! H
[GOAL]
case intro.intro.intro.intro.intro.refine'_1.hi
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
v : V
hvt : v ∈ t
H : ¬{ val := v, property := hvt } ∈ s
⊢ (if { val := v, property := hvt } ∈ s then g { val := v, property := hvt } else 0) • v = 0
[PROOFSTEP]
rw [if_neg H, zero_smul]
[GOAL]
case intro.intro.intro.intro.intro.refine'_1.i_inj
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
⊢ ∀ (a₁ a₂ : V) (h₁₁ : a₁ ∈ t),
    (if h : a₁ ∈ t then if { val := a₁, property := h } ∈ s then g { val := a₁, property := h } else 0 else 0) • a₁ ≠
        0 →
      ∀ (h₂₁ : a₂ ∈ t),
        (if h : a₂ ∈ t then if { val := a₂, property := h } ∈ s then g { val := a₂, property := h } else 0 else 0) •
              a₂ ≠
            0 →
          { val := a₁, property := h₁₁ } = { val := a₂, property := h₂₁ } → a₁ = a₂
[PROOFSTEP]
intro _ _ _ _ _ _
[GOAL]
case intro.intro.intro.intro.intro.refine'_1.i_inj
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
a₁✝ a₂✝ : V
h₁₁✝ : a₁✝ ∈ t
h₁₂✝ :
  (if h : a₁✝ ∈ t then if { val := a₁✝, property := h } ∈ s then g { val := a₁✝, property := h } else 0 else 0) • a₁✝ ≠
    0
h₂₁✝ : a₂✝ ∈ t
h₂₂✝ :
  (if h : a₂✝ ∈ t then if { val := a₂✝, property := h } ∈ s then g { val := a₂✝, property := h } else 0 else 0) • a₂✝ ≠
    0
⊢ { val := a₁✝, property := h₁₁✝ } = { val := a₂✝, property := h₂₁✝ } → a₁✝ = a₂✝
[PROOFSTEP]
exact Subtype.mk.inj
[GOAL]
case intro.intro.intro.intro.intro.refine'_1.i_surj
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
⊢ ∀ (b : { v // v ∈ t }), b ∈ s → g b • ↑b ≠ 0 → ∃ a h₁ h₂, b = { val := a, property := h₁ }
[PROOFSTEP]
intro b hbs hb
[GOAL]
case intro.intro.intro.intro.intro.refine'_1.i_surj
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
b : { v // v ∈ t }
hbs : b ∈ s
hb : g b • ↑b ≠ 0
⊢ ∃ a h₁ h₂, b = { val := a, property := h₁ }
[PROOFSTEP]
use b
[GOAL]
case h
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
b : { v // v ∈ t }
hbs : b ∈ s
hb : g b • ↑b ≠ 0
⊢ ∃ h₁ h₂, b = { val := ↑b, property := h₁ }
[PROOFSTEP]
simpa only [hbs, exists_prop, dif_pos, Finset.mk_coe, and_true_iff, if_true, Finset.coe_mem, eq_self_iff_true,
  exists_prop_of_true, Ne.def] using hb
[GOAL]
case intro.intro.intro.intro.intro.refine'_1.h
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
⊢ ∀ (a : V) (h₁ : a ∈ t),
    (if h : a ∈ t then if { val := a, property := h } ∈ s then g { val := a, property := h } else 0 else 0) • a ≠ 0 →
      (if h : a ∈ t then if { val := a, property := h } ∈ s then g { val := a, property := h } else 0 else 0) • a =
        g { val := a, property := h₁ } • ↑{ val := a, property := h₁ }
[PROOFSTEP]
intro a h₁
[GOAL]
case intro.intro.intro.intro.intro.refine'_1.h
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
a : V
h₁ : a ∈ t
⊢ (if h : a ∈ t then if { val := a, property := h } ∈ s then g { val := a, property := h } else 0 else 0) • a ≠ 0 →
    (if h : a ∈ t then if { val := a, property := h } ∈ s then g { val := a, property := h } else 0 else 0) • a =
      g { val := a, property := h₁ } • ↑{ val := a, property := h₁ }
[PROOFSTEP]
dsimp
[GOAL]
case intro.intro.intro.intro.intro.refine'_1.h
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
a : V
h₁ : a ∈ t
⊢ ¬(if h : a ∈ t then if { val := a, property := h } ∈ s then g { val := a, property := h } else 0 else 0) • a = 0 →
    (if h : a ∈ t then if { val := a, property := h } ∈ s then g { val := a, property := h } else 0 else 0) • a =
      g { val := a, property := h₁ } • a
[PROOFSTEP]
rw [dif_pos h₁]
[GOAL]
case intro.intro.intro.intro.intro.refine'_1.h
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
a : V
h₁ : a ∈ t
⊢ ¬(if { val := a, property := h₁ } ∈ s then g { val := a, property := h₁ } else 0) • a = 0 →
    (if { val := a, property := h₁ } ∈ s then g { val := a, property := h₁ } else 0) • a =
      g { val := a, property := h₁ } • a
[PROOFSTEP]
intro h₂
[GOAL]
case intro.intro.intro.intro.intro.refine'_1.h
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
a : V
h₁ : a ∈ t
h₂ : ¬(if { val := a, property := h₁ } ∈ s then g { val := a, property := h₁ } else 0) • a = 0
⊢ (if { val := a, property := h₁ } ∈ s then g { val := a, property := h₁ } else 0) • a =
    g { val := a, property := h₁ } • a
[PROOFSTEP]
rw [if_pos]
[GOAL]
case intro.intro.intro.intro.intro.refine'_1.h.hc
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
a : V
h₁ : a ∈ t
h₂ : ¬(if { val := a, property := h₁ } ∈ s then g { val := a, property := h₁ } else 0) • a = 0
⊢ { val := a, property := h₁ } ∈ s
[PROOFSTEP]
contrapose! h₂
[GOAL]
case intro.intro.intro.intro.intro.refine'_1.h.hc
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
a : V
h₁ : a ∈ t
h₂ : ¬{ val := a, property := h₁ } ∈ s
⊢ (if { val := a, property := h₁ } ∈ s then g { val := a, property := h₁ } else 0) • a = 0
[PROOFSTEP]
rw [if_neg h₂, zero_smul]
[GOAL]
case intro.intro.intro.intro.intro.refine'_2
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
⊢ ∃ x, x ∈ t ∧ f x ≠ 0
[PROOFSTEP]
refine' ⟨z, z.2, _⟩
[GOAL]
case intro.intro.intro.intro.intro.refine'_2
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
⊢ f ↑z ≠ 0
[PROOFSTEP]
dsimp only
[GOAL]
case intro.intro.intro.intro.intro.refine'_2
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
⊢ (if h : ↑z ∈ t then if { val := ↑z, property := h } ∈ s then g { val := ↑z, property := h } else 0 else 0) ≠ 0
[PROOFSTEP]
erw [dif_pos z.2, if_pos]
[GOAL]
case intro.intro.intro.intro.intro.refine'_2
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
⊢ g { val := ↑z, property := (_ : ↑z ∈ t) } ≠ 0
[PROOFSTEP]
rwa [Subtype.coe_eta]
[GOAL]
case intro.intro.intro.intro.intro.refine'_2.hc
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V < card t
s : Finset { x // x ∈ t }
g : { x // x ∈ t } → K
sum : ∑ i in s, g i • ↑i = 0
z : { x // x ∈ t }
zm : z ∈ s
nonzero : g z ≠ 0
f : V → K :=
  fun x => if h : x ∈ t then if { val := x, property := h } ∈ s then g { val := x, property := h } else 0 else 0
⊢ { val := ↑z, property := (_ : ↑z ∈ t) } ∈ s
[PROOFSTEP]
rwa [Subtype.coe_eta]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
⊢ ∃ f, ∑ e in t, f e • e = 0 ∧ ∑ e in t, f e = 0 ∧ ∃ x, x ∈ t ∧ f x ≠ 0
[PROOFSTEP]
classical
  -- Pick an element x₀ ∈ t,
have card_pos : 0 < t.card := lt_trans (Nat.succ_pos _) h
obtain ⟨x₀, m⟩ := (Finset.card_pos.1 card_pos).bex
let shift : V ↪ V := ⟨fun x => x - x₀, sub_left_injective⟩
let t' := (t.erase x₀).map shift
have h' : finrank K V < t'.card := by
  simp only [card_map, Finset.card_erase_of_mem m]
  exact Nat.lt_pred_iff.mpr h
obtain ⟨g, gsum, x₁, x₁_mem, nz⟩ := exists_nontrivial_relation_of_rank_lt_card h'
let f : V → K := fun z => if z = x₀ then -∑ z in t.erase x₀, g (z - x₀) else g (z - x₀)
refine'
  ⟨f, _, _, _⟩
    -- After this, it's a matter of verifying the properties,
      -- based on the corresponding properties for `g`.
· show
    (∑ e : V in t, f e • e) =
      0
        -- We prove this by splitting off the `x₀` term of the sum,
            -- which is itself a sum over `t.erase x₀`,
            -- combining the two sums, and
            -- observing that after reindexing we have exactly
            -- ∑ (x : V) in t', g x • x = 0.
  simp only
  conv_lhs =>
    apply_congr
    rfl
    rw [ite_smul]
  rw [Finset.sum_ite]
  conv =>
    congr
    congr
    apply_congr
      -- Porting note: the next two steps used to work by `simp [filter_eq', m]`
    erw [filter_eq']
    simp [m]
  conv =>
    congr
    congr
    rfl
    apply_congr
    simp [filter_ne']
  rw [sum_singleton, neg_smul, add_comm, ← sub_eq_add_neg, sum_smul, ← sum_sub_distrib]
  simp only [← smul_sub]
    -- At the end we have to reindex the sum, so we use `change` to
        -- express the summand using `shift`.
  change
    (∑ x : V in t.erase x₀, (fun e => g e • e) (shift x)) =
      0
        -- porting note: last argument can't be inferred
  rw [← sum_map _ shift (fun e => g e • e)]
  exact gsum
· show
    (∑ e : V in t, f e) =
      0
        -- Again we split off the `x₀` term,
            -- observing that it exactly cancels the other terms.
  rw [← insert_erase m, sum_insert (not_mem_erase x₀ t)]
  dsimp
  rw [if_pos rfl]
  conv_lhs =>
    congr
    rfl
    apply_congr
    rfl
    rw [if_neg (show _ ≠ x₀ from (mem_erase.mp ‹_›).1)]
  exact neg_add_self _
· show
    ∃ (x : V),
      x ∈ t ∧
        f x ≠
          0
            -- We can use x₁ + x₀.
  refine' ⟨x₁ + x₀, _, _⟩
  · rw [Finset.mem_map] at x₁_mem 
    rcases x₁_mem with ⟨x₁, x₁_mem, rfl⟩
    rw [mem_erase] at x₁_mem 
    simp only [x₁_mem, sub_add_cancel, Function.Embedding.coeFn_mk]
  · dsimp only
    rwa [if_neg, add_sub_cancel]
    rw [add_left_eq_self]
    rintro rfl
    simp only [sub_eq_zero, exists_prop, Finset.mem_map, Embedding.coeFn_mk, eq_self_iff_true, mem_erase, not_true,
      exists_eq_right, Ne.def, false_and_iff] at x₁_mem 
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
⊢ ∃ f, ∑ e in t, f e • e = 0 ∧ ∑ e in t, f e = 0 ∧ ∃ x, x ∈ t ∧ f x ≠ 0
[PROOFSTEP]
have card_pos : 0 < t.card := lt_trans (Nat.succ_pos _) h
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
⊢ ∃ f, ∑ e in t, f e • e = 0 ∧ ∑ e in t, f e = 0 ∧ ∃ x, x ∈ t ∧ f x ≠ 0
[PROOFSTEP]
obtain ⟨x₀, m⟩ := (Finset.card_pos.1 card_pos).bex
[GOAL]
case intro
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
⊢ ∃ f, ∑ e in t, f e • e = 0 ∧ ∑ e in t, f e = 0 ∧ ∃ x, x ∈ t ∧ f x ≠ 0
[PROOFSTEP]
let shift : V ↪ V := ⟨fun x => x - x₀, sub_left_injective⟩
[GOAL]
case intro
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
⊢ ∃ f, ∑ e in t, f e • e = 0 ∧ ∑ e in t, f e = 0 ∧ ∃ x, x ∈ t ∧ f x ≠ 0
[PROOFSTEP]
let t' := (t.erase x₀).map shift
[GOAL]
case intro
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
⊢ ∃ f, ∑ e in t, f e • e = 0 ∧ ∑ e in t, f e = 0 ∧ ∃ x, x ∈ t ∧ f x ≠ 0
[PROOFSTEP]
have h' : finrank K V < t'.card := by
  simp only [card_map, Finset.card_erase_of_mem m]
  exact Nat.lt_pred_iff.mpr h
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
⊢ finrank K V < card t'
[PROOFSTEP]
simp only [card_map, Finset.card_erase_of_mem m]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
⊢ finrank K V < card t - 1
[PROOFSTEP]
exact Nat.lt_pred_iff.mpr h
[GOAL]
case intro
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
⊢ ∃ f, ∑ e in t, f e • e = 0 ∧ ∑ e in t, f e = 0 ∧ ∃ x, x ∈ t ∧ f x ≠ 0
[PROOFSTEP]
obtain ⟨g, gsum, x₁, x₁_mem, nz⟩ := exists_nontrivial_relation_of_rank_lt_card h'
[GOAL]
case intro.intro.intro.intro.intro
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
⊢ ∃ f, ∑ e in t, f e • e = 0 ∧ ∑ e in t, f e = 0 ∧ ∃ x, x ∈ t ∧ f x ≠ 0
[PROOFSTEP]
let f : V → K := fun z => if z = x₀ then -∑ z in t.erase x₀, g (z - x₀) else g (z - x₀)
[GOAL]
case intro.intro.intro.intro.intro
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ ∃ f, ∑ e in t, f e • e = 0 ∧ ∑ e in t, f e = 0 ∧ ∃ x, x ∈ t ∧ f x ≠ 0
[PROOFSTEP]
refine'
  ⟨f, _, _, _⟩
    -- After this, it's a matter of verifying the properties,
      -- based on the corresponding properties for `g`.
[GOAL]
case intro.intro.intro.intro.intro.refine'_1
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ ∑ e in t, f e • e = 0
[PROOFSTEP]
show
  (∑ e : V in t, f e • e) =
    0
      -- We prove this by splitting off the `x₀` term of the sum,
          -- which is itself a sum over `t.erase x₀`,
          -- combining the two sums, and
          -- observing that after reindexing we have exactly
          -- ∑ (x : V) in t', g x • x = 0.
[GOAL]
case intro.intro.intro.intro.intro.refine'_1
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ ∑ e in t, f e • e = 0
[PROOFSTEP]
simp only
[GOAL]
case intro.intro.intro.intro.intro.refine'_1
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ ∑ x in t, (if x = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (x - x₀)) • x = 0
[PROOFSTEP]
conv_lhs =>
  apply_congr
  rfl
  rw [ite_smul]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| ∑ x in t, (if x = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (x - x₀)) • x
[PROOFSTEP]
  apply_congr
  rfl
  rw [ite_smul]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| ∑ x in t, (if x = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (x - x₀)) • x
[PROOFSTEP]
  apply_congr
  rfl
  rw [ite_smul]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| ∑ x in t, (if x = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (x - x₀)) • x
[PROOFSTEP]
apply_congr
[GOAL]
case h
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ t = ?s₂
case a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
x✝ : V
a✝ : x✝ ∈ ?s₂
⊢ (if x✝ = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (x✝ - x₀)) • x✝ = ?g x✝
[PROOFSTEP]
rfl
[GOAL]
case a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
x✝ : V
a✝ : x✝ ∈ t
⊢ (if x✝ = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (x✝ - x₀)) • x✝ = ?g x✝
[PROOFSTEP]
rw [ite_smul]
[GOAL]
case intro.intro.intro.intro.intro.refine'_1
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ (∑ x in t, if x = x₀ then (-∑ z in erase t x₀, g (z - x₀)) • x else g (x - x₀) • x) = 0
[PROOFSTEP]
rw [Finset.sum_ite]
[GOAL]
case intro.intro.intro.intro.intro.refine'_1
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ ∑ x in filter (fun x => x = x₀) t, (-∑ z in erase t x₀, g (z - x₀)) • x +
      ∑ x in filter (fun x => ¬x = x₀) t, g (x - x₀) • x =
    0
[PROOFSTEP]
conv =>
  congr
  congr
  apply_congr
    -- Porting note: the next two steps used to work by `simp [filter_eq', m]`
  erw [filter_eq']
  simp [m]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| ∑ x in filter (fun x => x = x₀) t, (-∑ z in erase t x₀, g (z - x₀)) • x +
      ∑ x in filter (fun x => ¬x = x₀) t, g (x - x₀) • x =
    0
[PROOFSTEP]
  congr
  congr
  apply_congr
    -- Porting note: the next two steps used to work by `simp [filter_eq', m]`
  erw [filter_eq']
  simp [m]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| ∑ x in filter (fun x => x = x₀) t, (-∑ z in erase t x₀, g (z - x₀)) • x +
      ∑ x in filter (fun x => ¬x = x₀) t, g (x - x₀) • x =
    0
[PROOFSTEP]
  congr
  congr
  apply_congr
    -- Porting note: the next two steps used to work by `simp [filter_eq', m]`
  erw [filter_eq']
  simp [m]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| ∑ x in filter (fun x => x = x₀) t, (-∑ z in erase t x₀, g (z - x₀)) • x +
      ∑ x in filter (fun x => ¬x = x₀) t, g (x - x₀) • x =
    0
[PROOFSTEP]
congr
[GOAL]
case a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| ∑ x in filter (fun x => x = x₀) t, (-∑ z in erase t x₀, g (z - x₀)) • x +
    ∑ x in filter (fun x => ¬x = x₀) t, g (x - x₀) • x
case a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| 0
[PROOFSTEP]
congr
[GOAL]
case a.a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| ∑ x in filter (fun x => x = x₀) t, (-∑ z in erase t x₀, g (z - x₀)) • x
case a.a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| ∑ x in filter (fun x => ¬x = x₀) t, g (x - x₀) • x
case a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| 0
[PROOFSTEP]
apply_congr
  -- Porting note: the next two steps used to work by `simp [filter_eq', m]`
[GOAL]
case a.a.h
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ filter (fun x => x = x₀) t = ?a.a.s₂
case a.a.a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
x✝ : V
a✝ : x✝ ∈ ?a.a.s₂
⊢ (-∑ z in erase t x₀, g (z - x₀)) • x✝ = ?a.a.g x✝
case a.a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| ∑ x in filter (fun x => ¬x = x₀) t, g (x - x₀) • x
case a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| 0
[PROOFSTEP]
erw [filter_eq']
[GOAL]
case a.a.h
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| if x₀ ∈ t then {x₀} else ∅
case a.a.a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
x✝ : V
a✝ : x✝ ∈ ?a.a.s₂
⊢ (-∑ z in erase t x₀, g (z - x₀)) • x✝ = ?a.a.g x✝
case a.a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| ∑ x in filter (fun x => ¬x = x₀) t, g (x - x₀) • x
case a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| 0
[PROOFSTEP]
simp [m]
[GOAL]
case intro.intro.intro.intro.intro.refine'_1
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ ∑ x in {x₀}, (-∑ z in erase t x₀, g (z - x₀)) • x + ∑ x in filter (fun x => ¬x = x₀) t, g (x - x₀) • x = 0
[PROOFSTEP]
conv =>
  congr
  congr
  rfl
  apply_congr
  simp [filter_ne']
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| ∑ x in {x₀}, (-∑ z in erase t x₀, g (z - x₀)) • x + ∑ x in filter (fun x => ¬x = x₀) t, g (x - x₀) • x = 0
[PROOFSTEP]
  congr
  congr
  rfl
  apply_congr
  simp [filter_ne']
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| ∑ x in {x₀}, (-∑ z in erase t x₀, g (z - x₀)) • x + ∑ x in filter (fun x => ¬x = x₀) t, g (x - x₀) • x = 0
[PROOFSTEP]
  congr
  congr
  rfl
  apply_congr
  simp [filter_ne']
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| ∑ x in {x₀}, (-∑ z in erase t x₀, g (z - x₀)) • x + ∑ x in filter (fun x => ¬x = x₀) t, g (x - x₀) • x = 0
[PROOFSTEP]
congr
[GOAL]
case a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| ∑ x in {x₀}, (-∑ z in erase t x₀, g (z - x₀)) • x + ∑ x in filter (fun x => ¬x = x₀) t, g (x - x₀) • x
case a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| 0
[PROOFSTEP]
congr
[GOAL]
case a.a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| ∑ x in {x₀}, (-∑ z in erase t x₀, g (z - x₀)) • x
case a.a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| ∑ x in filter (fun x => ¬x = x₀) t, g (x - x₀) • x
case a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| 0
[PROOFSTEP]
rfl
[GOAL]
case a.a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| ∑ x in filter (fun x => ¬x = x₀) t, g (x - x₀) • x
case a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| 0
[PROOFSTEP]
apply_congr
[GOAL]
case a.a.h
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ filter (fun x => ¬x = x₀) t = ?a.a.s₂
case a.a.a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
x✝ : V
a✝ : x✝ ∈ ?a.a.s₂
⊢ g (x✝ - x₀) • x✝ = ?a.a.g x✝
case a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| 0
[PROOFSTEP]
simp [filter_ne']
[GOAL]
case intro.intro.intro.intro.intro.refine'_1
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ ∑ x in {x₀}, (-∑ z in erase t x₀, g (z - x₀)) • x + ∑ x in erase t x₀, g (x - x₀) • x = 0
[PROOFSTEP]
rw [sum_singleton, neg_smul, add_comm, ← sub_eq_add_neg, sum_smul, ← sum_sub_distrib]
[GOAL]
case intro.intro.intro.intro.intro.refine'_1
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ ∑ x in erase t x₀, (g (x - x₀) • x - g (x - x₀) • x₀) = 0
[PROOFSTEP]
simp only [← smul_sub]
  -- At the end we have to reindex the sum, so we use `change` to
      -- express the summand using `shift`.
[GOAL]
case intro.intro.intro.intro.intro.refine'_1
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ ∑ x in erase t x₀, g (x - x₀) • (x - x₀) = 0
[PROOFSTEP]
change
  (∑ x : V in t.erase x₀, (fun e => g e • e) (shift x)) =
    0
      -- porting note: last argument can't be inferred
[GOAL]
case intro.intro.intro.intro.intro.refine'_1
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ ∑ x in erase t x₀, (fun e => g e • e) (↑shift x) = 0
[PROOFSTEP]
rw [← sum_map _ shift (fun e => g e • e)]
[GOAL]
case intro.intro.intro.intro.intro.refine'_1
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ ∑ x in Finset.map shift (erase t x₀), g x • x = 0
[PROOFSTEP]
exact gsum
[GOAL]
case intro.intro.intro.intro.intro.refine'_2
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ ∑ e in t, f e = 0
[PROOFSTEP]
show
  (∑ e : V in t, f e) =
    0
      -- Again we split off the `x₀` term,
          -- observing that it exactly cancels the other terms.
[GOAL]
case intro.intro.intro.intro.intro.refine'_2
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ ∑ e in t, f e = 0
[PROOFSTEP]
rw [← insert_erase m, sum_insert (not_mem_erase x₀ t)]
[GOAL]
case intro.intro.intro.intro.intro.refine'_2
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ f x₀ + ∑ x in erase t x₀, f x = 0
[PROOFSTEP]
dsimp
[GOAL]
case intro.intro.intro.intro.intro.refine'_2
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ ((if x₀ = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (x₀ - x₀)) +
      ∑ x in erase t x₀, if x = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (x - x₀)) =
    0
[PROOFSTEP]
rw [if_pos rfl]
[GOAL]
case intro.intro.intro.intro.intro.refine'_2
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ (-∑ z in erase t x₀, g (z - x₀) + ∑ x in erase t x₀, if x = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (x - x₀)) =
    0
[PROOFSTEP]
conv_lhs =>
  congr
  rfl
  apply_congr
  rfl
  rw [if_neg (show _ ≠ x₀ from (mem_erase.mp ‹_›).1)]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| -∑ z in erase t x₀, g (z - x₀) + ∑ x in erase t x₀, if x = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (x - x₀)
[PROOFSTEP]
  congr
  rfl
  apply_congr
  rfl
  rw [if_neg (show _ ≠ x₀ from (mem_erase.mp ‹_›).1)]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| -∑ z in erase t x₀, g (z - x₀) + ∑ x in erase t x₀, if x = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (x - x₀)
[PROOFSTEP]
  congr
  rfl
  apply_congr
  rfl
  rw [if_neg (show _ ≠ x₀ from (mem_erase.mp ‹_›).1)]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| -∑ z in erase t x₀, g (z - x₀) + ∑ x in erase t x₀, if x = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (x - x₀)
[PROOFSTEP]
congr
[GOAL]
case a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| -∑ z in erase t x₀, g (z - x₀)
case a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| ∑ x in erase t x₀, if x = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (x - x₀)
[PROOFSTEP]
rfl
[GOAL]
case a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
| ∑ x in erase t x₀, if x = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (x - x₀)
[PROOFSTEP]
apply_congr
[GOAL]
case a.h
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ erase t x₀ = ?a.s₂
case a.a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
x✝ : V
a✝ : x✝ ∈ ?a.s₂
⊢ (if x✝ = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (x✝ - x₀)) = ?a.g x✝
[PROOFSTEP]
rfl
[GOAL]
case a.a
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
x✝ : V
a✝ : x✝ ∈ erase t x₀
⊢ (if x✝ = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (x✝ - x₀)) = ?a.g x✝
[PROOFSTEP]
rw [if_neg (show _ ≠ x₀ from (mem_erase.mp ‹_›).1)]
[GOAL]
case intro.intro.intro.intro.intro.refine'_2
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ -∑ z in erase t x₀, g (z - x₀) + ∑ x in erase t x₀, g (x - x₀) = 0
[PROOFSTEP]
exact neg_add_self _
[GOAL]
case intro.intro.intro.intro.intro.refine'_3
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ ∃ x, x ∈ t ∧ f x ≠ 0
[PROOFSTEP]
show
  ∃ (x : V),
    x ∈ t ∧
      f x ≠
        0
          -- We can use x₁ + x₀.
[GOAL]
case intro.intro.intro.intro.intro.refine'_3
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ ∃ x, x ∈ t ∧ f x ≠ 0
[PROOFSTEP]
refine' ⟨x₁ + x₀, _, _⟩
[GOAL]
case intro.intro.intro.intro.intro.refine'_3.refine'_1
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ x₁ + x₀ ∈ t
[PROOFSTEP]
rw [Finset.mem_map] at x₁_mem 
[GOAL]
case intro.intro.intro.intro.intro.refine'_3.refine'_1
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : ∃ a, a ∈ erase t x₀ ∧ ↑shift a = x₁
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ x₁ + x₀ ∈ t
[PROOFSTEP]
rcases x₁_mem with ⟨x₁, x₁_mem, rfl⟩
[GOAL]
case intro.intro.intro.intro.intro.refine'_3.refine'_1.intro.intro
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
x₁ : V
x₁_mem : x₁ ∈ erase t x₀
nz : g (↑shift x₁) ≠ 0
⊢ ↑shift x₁ + x₀ ∈ t
[PROOFSTEP]
rw [mem_erase] at x₁_mem 
[GOAL]
case intro.intro.intro.intro.intro.refine'_3.refine'_1.intro.intro
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
x₁ : V
x₁_mem : x₁ ≠ x₀ ∧ x₁ ∈ t
nz : g (↑shift x₁) ≠ 0
⊢ ↑shift x₁ + x₀ ∈ t
[PROOFSTEP]
simp only [x₁_mem, sub_add_cancel, Function.Embedding.coeFn_mk]
[GOAL]
case intro.intro.intro.intro.intro.refine'_3.refine'_2
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ f (x₁ + x₀) ≠ 0
[PROOFSTEP]
dsimp only
[GOAL]
case intro.intro.intro.intro.intro.refine'_3.refine'_2
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ (if x₁ + x₀ = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (x₁ + x₀ - x₀)) ≠ 0
[PROOFSTEP]
rwa [if_neg, add_sub_cancel]
[GOAL]
case intro.intro.intro.intro.intro.refine'_3.refine'_2.hnc
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ ¬x₁ + x₀ = x₀
[PROOFSTEP]
rw [add_left_eq_self]
[GOAL]
case intro.intro.intro.intro.intro.refine'_3.refine'_2.hnc
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
x₁ : V
x₁_mem : x₁ ∈ t'
nz : g x₁ ≠ 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
⊢ ¬x₁ = 0
[PROOFSTEP]
rintro rfl
[GOAL]
case intro.intro.intro.intro.intro.refine'_3.refine'_2.hnc
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
t : Finset V
h : finrank K V + 1 < card t
card_pos : 0 < card t
x₀ : V
m : x₀ ∈ t
shift : V ↪ V := { toFun := fun x => x - x₀, inj' := (_ : Injective fun a => a - x₀) }
t' : Finset V := Finset.map shift (erase t x₀)
h' : finrank K V < card t'
g : V → K
gsum : ∑ e in t', g e • e = 0
f : V → K := fun z => if z = x₀ then -∑ z in erase t x₀, g (z - x₀) else g (z - x₀)
x₁_mem : 0 ∈ t'
nz : g 0 ≠ 0
⊢ False
[PROOFSTEP]
simp only [sub_eq_zero, exists_prop, Finset.mem_map, Embedding.coeFn_mk, eq_self_iff_true, mem_erase, not_true,
  exists_eq_right, Ne.def, false_and_iff] at x₁_mem 
[GOAL]
K : Type u
V : Type v
inst✝⁸ : DivisionRing K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
V₂ : Type v'
inst✝⁵ : AddCommGroup V₂
inst✝⁴ : Module K V₂
L : Type u_1
inst✝³ : LinearOrderedField L
W : Type v
inst✝² : AddCommGroup W
inst✝¹ : Module L W
inst✝ : FiniteDimensional L W
t : Finset W
h : finrank L W + 1 < card t
⊢ ∃ f, ∑ e in t, f e • e = 0 ∧ ∑ e in t, f e = 0 ∧ ∃ x, x ∈ t ∧ 0 < f x
[PROOFSTEP]
obtain ⟨f, sum, total, nonzero⟩ := exists_nontrivial_relation_sum_zero_of_rank_succ_lt_card h
[GOAL]
case intro.intro.intro
K : Type u
V : Type v
inst✝⁸ : DivisionRing K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
V₂ : Type v'
inst✝⁵ : AddCommGroup V₂
inst✝⁴ : Module K V₂
L : Type u_1
inst✝³ : LinearOrderedField L
W : Type v
inst✝² : AddCommGroup W
inst✝¹ : Module L W
inst✝ : FiniteDimensional L W
t : Finset W
h : finrank L W + 1 < card t
f : W → L
sum : ∑ e in t, f e • e = 0
total : ∑ e in t, f e = 0
nonzero : ∃ x, x ∈ t ∧ f x ≠ 0
⊢ ∃ f, ∑ e in t, f e • e = 0 ∧ ∑ e in t, f e = 0 ∧ ∃ x, x ∈ t ∧ 0 < f x
[PROOFSTEP]
exact ⟨f, sum, total, exists_pos_of_sum_zero_of_exists_nonzero f total nonzero⟩
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type u_1
inst✝ : Unique ι
h✝ : finrank K V = 1
v : V
hv : v ≠ 0
b : Basis ι K V := basisUnique ι h✝
h : ↑(↑b.repr v) default ≠ 0 := mt basisUnique.repr_eq_zero_iff.mp hv
⊢ ∀ (x y : V),
    (fun w => Finsupp.single default (↑(↑b.repr w) default / ↑(↑b.repr v) default)) (x + y) =
      (fun w => Finsupp.single default (↑(↑b.repr w) default / ↑(↑b.repr v) default)) x +
        (fun w => Finsupp.single default (↑(↑b.repr w) default / ↑(↑b.repr v) default)) y
[PROOFSTEP]
simp [add_div]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type u_1
inst✝ : Unique ι
h✝ : finrank K V = 1
v : V
hv : v ≠ 0
b : Basis ι K V := basisUnique ι h✝
h : ↑(↑b.repr v) default ≠ 0 := mt basisUnique.repr_eq_zero_iff.mp hv
⊢ ∀ (r : K) (x : V),
    AddHom.toFun
        { toFun := fun w => Finsupp.single default (↑(↑b.repr w) default / ↑(↑b.repr v) default),
          map_add' :=
            (_ :
              ∀ (a a_1 : V),
                Finsupp.single default
                    (↑(↑(basisUnique ι h✝).repr (a + a_1)) default / ↑(↑(basisUnique ι h✝).repr v) default) =
                  Finsupp.single default
                      (↑(↑(basisUnique ι h✝).repr a) default / ↑(↑(basisUnique ι h✝).repr v) default) +
                    Finsupp.single default
                      (↑(↑(basisUnique ι h✝).repr a_1) default / ↑(↑(basisUnique ι h✝).repr v) default)) }
        (r • x) =
      ↑(RingHom.id K) r •
        AddHom.toFun
          { toFun := fun w => Finsupp.single default (↑(↑b.repr w) default / ↑(↑b.repr v) default),
            map_add' :=
              (_ :
                ∀ (a a_1 : V),
                  Finsupp.single default
                      (↑(↑(basisUnique ι h✝).repr (a + a_1)) default / ↑(↑(basisUnique ι h✝).repr v) default) =
                    Finsupp.single default
                        (↑(↑(basisUnique ι h✝).repr a) default / ↑(↑(basisUnique ι h✝).repr v) default) +
                      Finsupp.single default
                        (↑(↑(basisUnique ι h✝).repr a_1) default / ↑(↑(basisUnique ι h✝).repr v) default)) }
          x
[PROOFSTEP]
simp [mul_div]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type u_1
inst✝ : Unique ι
h✝ : finrank K V = 1
v : V
hv : v ≠ 0
b : Basis ι K V := basisUnique ι h✝
h : ↑(↑b.repr v) default ≠ 0 := mt basisUnique.repr_eq_zero_iff.mp hv
w : V
⊢ (fun f => ↑f default • v)
      (AddHom.toFun
        {
            toAddHom :=
              { toFun := fun w => Finsupp.single default (↑(↑b.repr w) default / ↑(↑b.repr v) default),
                map_add' :=
                  (_ :
                    ∀ (a a_1 : V),
                      Finsupp.single default
                          (↑(↑(basisUnique ι h✝).repr (a + a_1)) default / ↑(↑(basisUnique ι h✝).repr v) default) =
                        Finsupp.single default
                            (↑(↑(basisUnique ι h✝).repr a) default / ↑(↑(basisUnique ι h✝).repr v) default) +
                          Finsupp.single default
                            (↑(↑(basisUnique ι h✝).repr a_1) default / ↑(↑(basisUnique ι h✝).repr v) default)) },
            map_smul' :=
              (_ :
                ∀ (a : K) (a_1 : V),
                  Finsupp.single default
                      (↑(↑(basisUnique ι h✝).repr (a • a_1)) default / ↑(↑(basisUnique ι h✝).repr v) default) =
                    a •
                      Finsupp.single default
                        (↑(↑(basisUnique ι h✝).repr a_1) default / ↑(↑(basisUnique ι h✝).repr v) default)) }.toAddHom
        w) =
    w
[PROOFSTEP]
apply_fun b.repr using b.repr.toEquiv.injective
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type u_1
inst✝ : Unique ι
h✝ : finrank K V = 1
v : V
hv : v ≠ 0
b : Basis ι K V := basisUnique ι h✝
h : ↑(↑b.repr v) default ≠ 0 := mt basisUnique.repr_eq_zero_iff.mp hv
w : V
⊢ ↑b.repr
      ((fun f => ↑f default • v)
        (AddHom.toFun
          {
              toAddHom :=
                { toFun := fun w => Finsupp.single default (↑(↑b.repr w) default / ↑(↑b.repr v) default),
                  map_add' :=
                    (_ :
                      ∀ (a a_1 : V),
                        Finsupp.single default
                            (↑(↑(basisUnique ι h✝).repr (a + a_1)) default / ↑(↑(basisUnique ι h✝).repr v) default) =
                          Finsupp.single default
                              (↑(↑(basisUnique ι h✝).repr a) default / ↑(↑(basisUnique ι h✝).repr v) default) +
                            Finsupp.single default
                              (↑(↑(basisUnique ι h✝).repr a_1) default / ↑(↑(basisUnique ι h✝).repr v) default)) },
              map_smul' :=
                (_ :
                  ∀ (a : K) (a_1 : V),
                    Finsupp.single default
                        (↑(↑(basisUnique ι h✝).repr (a • a_1)) default / ↑(↑(basisUnique ι h✝).repr v) default) =
                      a •
                        Finsupp.single default
                          (↑(↑(basisUnique ι h✝).repr a_1) default / ↑(↑(basisUnique ι h✝).repr v) default)) }.toAddHom
          w)) =
    ↑b.repr w
[PROOFSTEP]
apply_fun Equiv.finsuppUnique
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type u_1
inst✝ : Unique ι
h✝ : finrank K V = 1
v : V
hv : v ≠ 0
b : Basis ι K V := basisUnique ι h✝
h : ↑(↑b.repr v) default ≠ 0 := mt basisUnique.repr_eq_zero_iff.mp hv
w : V
⊢ ↑Equiv.finsuppUnique
      (↑b.repr
        ((fun f => ↑f default • v)
          (AddHom.toFun
            {
                toAddHom :=
                  { toFun := fun w => Finsupp.single default (↑(↑b.repr w) default / ↑(↑b.repr v) default),
                    map_add' :=
                      (_ :
                        ∀ (a a_1 : V),
                          Finsupp.single default
                              (↑(↑(basisUnique ι h✝).repr (a + a_1)) default / ↑(↑(basisUnique ι h✝).repr v) default) =
                            Finsupp.single default
                                (↑(↑(basisUnique ι h✝).repr a) default / ↑(↑(basisUnique ι h✝).repr v) default) +
                              Finsupp.single default
                                (↑(↑(basisUnique ι h✝).repr a_1) default / ↑(↑(basisUnique ι h✝).repr v) default)) },
                map_smul' :=
                  (_ :
                    ∀ (a : K) (a_1 : V),
                      Finsupp.single default
                          (↑(↑(basisUnique ι h✝).repr (a • a_1)) default / ↑(↑(basisUnique ι h✝).repr v) default) =
                        a •
                          Finsupp.single default
                            (↑(↑(basisUnique ι h✝).repr a_1) default /
                              ↑(↑(basisUnique ι h✝).repr v) default)) }.toAddHom
            w))) =
    ↑Equiv.finsuppUnique (↑b.repr w)
[PROOFSTEP]
simp only [LinearEquiv.map_smulₛₗ, Finsupp.coe_smul, Finsupp.single_eq_same, RingHom.id_apply, smul_eq_mul,
  Pi.smul_apply, Equiv.finsuppUnique_apply]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type u_1
inst✝ : Unique ι
h✝ : finrank K V = 1
v : V
hv : v ≠ 0
b : Basis ι K V := basisUnique ι h✝
h : ↑(↑b.repr v) default ≠ 0 := mt basisUnique.repr_eq_zero_iff.mp hv
w : V
⊢ ↑(↑(basisUnique ι h✝).repr w) default / ↑(↑(basisUnique ι h✝).repr v) default *
      ↑(↑(basisUnique ι h✝).repr v) default =
    ↑(↑(basisUnique ι h✝).repr w) default
[PROOFSTEP]
exact div_mul_cancel _ h
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type u_1
inst✝ : Unique ι
h✝ : finrank K V = 1
v : V
hv : v ≠ 0
b : Basis ι K V := basisUnique ι h✝
h : ↑(↑b.repr v) default ≠ 0 := mt basisUnique.repr_eq_zero_iff.mp hv
f : ι →₀ K
⊢ AddHom.toFun
      {
          toAddHom :=
            { toFun := fun w => Finsupp.single default (↑(↑b.repr w) default / ↑(↑b.repr v) default),
              map_add' :=
                (_ :
                  ∀ (a a_1 : V),
                    Finsupp.single default
                        (↑(↑(basisUnique ι h✝).repr (a + a_1)) default / ↑(↑(basisUnique ι h✝).repr v) default) =
                      Finsupp.single default
                          (↑(↑(basisUnique ι h✝).repr a) default / ↑(↑(basisUnique ι h✝).repr v) default) +
                        Finsupp.single default
                          (↑(↑(basisUnique ι h✝).repr a_1) default / ↑(↑(basisUnique ι h✝).repr v) default)) },
          map_smul' :=
            (_ :
              ∀ (a : K) (a_1 : V),
                Finsupp.single default
                    (↑(↑(basisUnique ι h✝).repr (a • a_1)) default / ↑(↑(basisUnique ι h✝).repr v) default) =
                  a •
                    Finsupp.single default
                      (↑(↑(basisUnique ι h✝).repr a_1) default / ↑(↑(basisUnique ι h✝).repr v) default)) }.toAddHom
      ((fun f => ↑f default • v) f) =
    f
[PROOFSTEP]
ext
[GOAL]
case h
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type u_1
inst✝ : Unique ι
h✝ : finrank K V = 1
v : V
hv : v ≠ 0
b : Basis ι K V := basisUnique ι h✝
h : ↑(↑b.repr v) default ≠ 0 := mt basisUnique.repr_eq_zero_iff.mp hv
f : ι →₀ K
⊢ ↑(AddHom.toFun
          {
              toAddHom :=
                { toFun := fun w => Finsupp.single default (↑(↑b.repr w) default / ↑(↑b.repr v) default),
                  map_add' :=
                    (_ :
                      ∀ (a a_1 : V),
                        Finsupp.single default
                            (↑(↑(basisUnique ι h✝).repr (a + a_1)) default / ↑(↑(basisUnique ι h✝).repr v) default) =
                          Finsupp.single default
                              (↑(↑(basisUnique ι h✝).repr a) default / ↑(↑(basisUnique ι h✝).repr v) default) +
                            Finsupp.single default
                              (↑(↑(basisUnique ι h✝).repr a_1) default / ↑(↑(basisUnique ι h✝).repr v) default)) },
              map_smul' :=
                (_ :
                  ∀ (a : K) (a_1 : V),
                    Finsupp.single default
                        (↑(↑(basisUnique ι h✝).repr (a • a_1)) default / ↑(↑(basisUnique ι h✝).repr v) default) =
                      a •
                        Finsupp.single default
                          (↑(↑(basisUnique ι h✝).repr a_1) default / ↑(↑(basisUnique ι h✝).repr v) default)) }.toAddHom
          ((fun f => ↑f default • v) f))
      default =
    ↑f default
[PROOFSTEP]
simp only [LinearEquiv.map_smulₛₗ, Finsupp.coe_smul, Finsupp.single_eq_same, RingHom.id_apply, smul_eq_mul,
  Pi.smul_apply]
[GOAL]
case h
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type u_1
inst✝ : Unique ι
h✝ : finrank K V = 1
v : V
hv : v ≠ 0
b : Basis ι K V := basisUnique ι h✝
h : ↑(↑b.repr v) default ≠ 0 := mt basisUnique.repr_eq_zero_iff.mp hv
f : ι →₀ K
⊢ ↑f default * ↑(↑(basisUnique ι h✝).repr v) default / ↑(↑(basisUnique ι h✝).repr v) default = ↑f default
[PROOFSTEP]
exact mul_div_cancel _ h
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type u_1
inst✝ : Unique ι
h : finrank K V = 1
v : V
hv : v ≠ 0
i : ι
⊢ ↑(basisSingleton ι h v hv) i = v
[PROOFSTEP]
cases Unique.uniq ‹Unique ι› i
[GOAL]
case refl
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type u_1
inst✝ : Unique ι
h : finrank K V = 1
v : V
hv : v ≠ 0
⊢ ↑(basisSingleton ι h v hv) default = v
[PROOFSTEP]
simp [basisSingleton]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type u_1
inst✝ : Unique ι
h : finrank K V = 1
v : V
hv : v ≠ 0
⊢ Set.range ↑(basisSingleton ι h v hv) = {v}
[PROOFSTEP]
rw [Set.range_unique, basisSingleton_apply]
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
n : ℕ
h : Module.rank K V = ↑n
⊢ FiniteDimensional K V
[PROOFSTEP]
rw [FiniteDimensional, ← IsNoetherian.iff_fg, IsNoetherian.iff_rank_lt_aleph0, h]
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
n : ℕ
h : Module.rank K V = ↑n
⊢ ↑n < ℵ₀
[PROOFSTEP]
exact nat_lt_aleph0 n
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
h : Module.rank K V = 0
⊢ finrank K V = 0
[PROOFSTEP]
convert finrank_eq_rank K V
[GOAL]
case a
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
h : Module.rank K V = 0
⊢ finrank K V = 0 ↔ ↑(finrank K V) = Module.rank K V
[PROOFSTEP]
rw [h]
[GOAL]
case a
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
h : Module.rank K V = 0
⊢ finrank K V = 0 ↔ ↑(finrank K V) = 0
[PROOFSTEP]
norm_cast
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
⊢ Module.rank K { x // x ∈ ⊥ } = 0
[PROOFSTEP]
simp
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : Module.rank K V = 0
⊢ ⊥ = ⊤
[PROOFSTEP]
haveI : FiniteDimensional _ _ := finiteDimensional_of_rank_eq_zero h
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : Module.rank K V = 0
this : FiniteDimensional K V
⊢ ⊥ = ⊤
[PROOFSTEP]
apply eq_top_of_finrank_eq
[GOAL]
case h
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : Module.rank K V = 0
this : FiniteDimensional K V
⊢ finrank K { x // x ∈ ⊥ } = finrank K V
[PROOFSTEP]
rw [finrank_bot, finrank_eq_zero_of_rank_eq_zero h]
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
S : Submodule K V
h : S = ⊥
⊢ Module.rank K { x // x ∈ S } = 0
[PROOFSTEP]
rw [h, rank_bot]
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
S : Submodule K V
inst✝ : FiniteDimensional K { x // x ∈ S }
⊢ finrank K { x // x ∈ S } = 0 ↔ S = ⊥
[PROOFSTEP]
rw [← rank_eq_zero, ← finrank_eq_rank, ← @Nat.cast_zero Cardinal, Cardinal.natCast_inj]
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
S₁ S₂ : Submodule K V
h₁ : FiniteDimensional K { x // x ∈ S₁ }
h₂ : FiniteDimensional K { x // x ∈ S₂ }
⊢ FiniteDimensional K { x // x ∈ S₁ ⊔ S₂ }
[PROOFSTEP]
unfold FiniteDimensional at *
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
S₁ S₂ : Submodule K V
h₁ : Module.Finite K { x // x ∈ S₁ }
h₂ : Module.Finite K { x // x ∈ S₂ }
⊢ Module.Finite K { x // x ∈ S₁ ⊔ S₂ }
[PROOFSTEP]
rw [finite_def] at *
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
S₁ S₂ : Submodule K V
h₁ : FG ⊤
h₂ : FG ⊤
⊢ FG ⊤
[PROOFSTEP]
exact (fg_top _).2 (((fg_top S₁).1 h₁).sup ((fg_top S₂).1 h₂))
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
s : Finset ι
S : ι → Submodule K V
inst✝ : ∀ (i : ι), FiniteDimensional K { x // x ∈ S i }
⊢ FiniteDimensional K { x // x ∈ Finset.sup s S }
[PROOFSTEP]
refine'
  @Finset.sup_induction _ _ _ _ s S (fun i => FiniteDimensional K ↑i) (finiteDimensional_bot K V) _ fun i _ => by
    infer_instance
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
s : Finset ι
S : ι → Submodule K V
inst✝ : ∀ (i : ι), FiniteDimensional K { x // x ∈ S i }
i : ι
x✝ : i ∈ s
⊢ (fun i => FiniteDimensional K { x // x ∈ i }) (S i)
[PROOFSTEP]
infer_instance
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
s : Finset ι
S : ι → Submodule K V
inst✝ : ∀ (i : ι), FiniteDimensional K { x // x ∈ S i }
⊢ ∀ (a₁ : Submodule K V),
    (fun i => FiniteDimensional K { x // x ∈ i }) a₁ →
      ∀ (a₂ : Submodule K V),
        (fun i => FiniteDimensional K { x // x ∈ i }) a₂ → (fun i => FiniteDimensional K { x // x ∈ i }) (a₁ ⊔ a₂)
[PROOFSTEP]
intro S₁ hS₁ S₂ hS₂
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
s : Finset ι
S : ι → Submodule K V
inst✝ : ∀ (i : ι), FiniteDimensional K { x // x ∈ S i }
S₁ : Submodule K V
hS₁ : FiniteDimensional K { x // x ∈ S₁ }
S₂ : Submodule K V
hS₂ : FiniteDimensional K { x // x ∈ S₂ }
⊢ FiniteDimensional K { x // x ∈ S₁ ⊔ S₂ }
[PROOFSTEP]
exact Submodule.finiteDimensional_sup S₁ S₂
[GOAL]
K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
ι : Sort u_1
inst✝¹ : _root_.Finite ι
S : ι → Submodule K V
inst✝ : ∀ (i : ι), FiniteDimensional K { x // x ∈ S i }
⊢ FiniteDimensional K { x // x ∈ ⨆ (i : ι), S i }
[PROOFSTEP]
cases nonempty_fintype (PLift ι)
[GOAL]
case intro
K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
ι : Sort u_1
inst✝¹ : _root_.Finite ι
S : ι → Submodule K V
inst✝ : ∀ (i : ι), FiniteDimensional K { x // x ∈ S i }
val✝ : Fintype (PLift ι)
⊢ FiniteDimensional K { x // x ∈ ⨆ (i : ι), S i }
[PROOFSTEP]
rw [← iSup_plift_down, ← Finset.sup_univ_eq_iSup]
[GOAL]
case intro
K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
ι : Sort u_1
inst✝¹ : _root_.Finite ι
S : ι → Submodule K V
inst✝ : ∀ (i : ι), FiniteDimensional K { x // x ∈ S i }
val✝ : Fintype (PLift ι)
⊢ FiniteDimensional K { x // x ∈ Finset.sup Finset.univ fun i => S i.down }
[PROOFSTEP]
exact Submodule.finiteDimensional_finset_sup _ _
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s : Submodule K V
⊢ finrank K (V ⧸ s) + finrank K { x // x ∈ s } = finrank K V
[PROOFSTEP]
have := rank_quotient_add_rank s
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s : Submodule K V
this : Module.rank K (V ⧸ s) + Module.rank K { x // x ∈ s } = Module.rank K V
⊢ finrank K (V ⧸ s) + finrank K { x // x ∈ s } = finrank K V
[PROOFSTEP]
rw [← finrank_eq_rank, ← finrank_eq_rank, ← finrank_eq_rank] at this 
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s : Submodule K V
this : ↑(finrank K (V ⧸ s)) + ↑(finrank K { x // x ∈ s }) = ↑(finrank K V)
⊢ finrank K (V ⧸ s) + finrank K { x // x ∈ s } = finrank K V
[PROOFSTEP]
exact_mod_cast this
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s : Submodule K V
h : s < ⊤
⊢ finrank K { x // x ∈ s } < finrank K V
[PROOFSTEP]
rw [← s.finrank_quotient_add_finrank, add_comm]
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s : Submodule K V
h : s < ⊤
⊢ finrank K { x // x ∈ s } < finrank K { x // x ∈ s } + finrank K (V ⧸ s)
[PROOFSTEP]
exact Nat.lt_add_of_pos_right (finrank_pos_iff.mpr (Quotient.nontrivial_of_lt_top _ h))
[GOAL]
K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s t : Submodule K V
inst✝¹ : FiniteDimensional K { x // x ∈ s }
inst✝ : FiniteDimensional K { x // x ∈ t }
⊢ finrank K { x // x ∈ s ⊔ t } + finrank K { x // x ∈ s ⊓ t } = finrank K { x // x ∈ s } + finrank K { x // x ∈ t }
[PROOFSTEP]
have key : Module.rank K ↑(s ⊔ t) + Module.rank K ↑(s ⊓ t) = Module.rank K s + Module.rank K t :=
  rank_sup_add_rank_inf_eq s t
[GOAL]
K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s t : Submodule K V
inst✝¹ : FiniteDimensional K { x // x ∈ s }
inst✝ : FiniteDimensional K { x // x ∈ t }
key :
  Module.rank K { x // x ∈ s ⊔ t } + Module.rank K { x // x ∈ s ⊓ t } =
    Module.rank K { x // x ∈ s } + Module.rank K { x // x ∈ t }
⊢ finrank K { x // x ∈ s ⊔ t } + finrank K { x // x ∈ s ⊓ t } = finrank K { x // x ∈ s } + finrank K { x // x ∈ t }
[PROOFSTEP]
repeat' rw [← finrank_eq_rank] at key 
[GOAL]
K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s t : Submodule K V
inst✝¹ : FiniteDimensional K { x // x ∈ s }
inst✝ : FiniteDimensional K { x // x ∈ t }
key :
  Module.rank K { x // x ∈ s ⊔ t } + Module.rank K { x // x ∈ s ⊓ t } =
    Module.rank K { x // x ∈ s } + Module.rank K { x // x ∈ t }
⊢ finrank K { x // x ∈ s ⊔ t } + finrank K { x // x ∈ s ⊓ t } = finrank K { x // x ∈ s } + finrank K { x // x ∈ t }
[PROOFSTEP]
rw [← finrank_eq_rank] at key 
[GOAL]
K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s t : Submodule K V
inst✝¹ : FiniteDimensional K { x // x ∈ s }
inst✝ : FiniteDimensional K { x // x ∈ t }
key :
  ↑(finrank K { x // x ∈ s ⊔ t }) + Module.rank K { x // x ∈ s ⊓ t } =
    Module.rank K { x // x ∈ s } + Module.rank K { x // x ∈ t }
⊢ finrank K { x // x ∈ s ⊔ t } + finrank K { x // x ∈ s ⊓ t } = finrank K { x // x ∈ s } + finrank K { x // x ∈ t }
[PROOFSTEP]
rw [← finrank_eq_rank] at key 
[GOAL]
K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s t : Submodule K V
inst✝¹ : FiniteDimensional K { x // x ∈ s }
inst✝ : FiniteDimensional K { x // x ∈ t }
key :
  ↑(finrank K { x // x ∈ s ⊔ t }) + ↑(finrank K { x // x ∈ s ⊓ t }) =
    Module.rank K { x // x ∈ s } + Module.rank K { x // x ∈ t }
⊢ finrank K { x // x ∈ s ⊔ t } + finrank K { x // x ∈ s ⊓ t } = finrank K { x // x ∈ s } + finrank K { x // x ∈ t }
[PROOFSTEP]
rw [← finrank_eq_rank] at key 
[GOAL]
K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s t : Submodule K V
inst✝¹ : FiniteDimensional K { x // x ∈ s }
inst✝ : FiniteDimensional K { x // x ∈ t }
key :
  ↑(finrank K { x // x ∈ s ⊔ t }) + ↑(finrank K { x // x ∈ s ⊓ t }) =
    ↑(finrank K { x // x ∈ s }) + Module.rank K { x // x ∈ t }
⊢ finrank K { x // x ∈ s ⊔ t } + finrank K { x // x ∈ s ⊓ t } = finrank K { x // x ∈ s } + finrank K { x // x ∈ t }
[PROOFSTEP]
rw [← finrank_eq_rank] at key 
[GOAL]
K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s t : Submodule K V
inst✝¹ : FiniteDimensional K { x // x ∈ s }
inst✝ : FiniteDimensional K { x // x ∈ t }
key :
  ↑(finrank K { x // x ∈ s ⊔ t }) + ↑(finrank K { x // x ∈ s ⊓ t }) =
    ↑(finrank K { x // x ∈ s }) + ↑(finrank K { x // x ∈ t })
⊢ finrank K { x // x ∈ s ⊔ t } + finrank K { x // x ∈ s ⊓ t } = finrank K { x // x ∈ s } + finrank K { x // x ∈ t }
[PROOFSTEP]
rw [← finrank_eq_rank] at key 
[GOAL]
K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s t : Submodule K V
inst✝¹ : FiniteDimensional K { x // x ∈ s }
inst✝ : FiniteDimensional K { x // x ∈ t }
key :
  ↑(finrank K { x // x ∈ s ⊔ t }) + ↑(finrank K { x // x ∈ s ⊓ t }) =
    ↑(finrank K { x // x ∈ s }) + ↑(finrank K { x // x ∈ t })
⊢ finrank K { x // x ∈ s ⊔ t } + finrank K { x // x ∈ s ⊓ t } = finrank K { x // x ∈ s } + finrank K { x // x ∈ t }
[PROOFSTEP]
norm_cast at key 
[GOAL]
K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s t : Submodule K V
inst✝¹ : FiniteDimensional K { x // x ∈ s }
inst✝ : FiniteDimensional K { x // x ∈ t }
⊢ finrank K { x // x ∈ s ⊔ t } ≤ finrank K { x // x ∈ s } + finrank K { x // x ∈ t }
[PROOFSTEP]
rw [← finrank_sup_add_finrank_inf_eq]
[GOAL]
K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s t : Submodule K V
inst✝¹ : FiniteDimensional K { x // x ∈ s }
inst✝ : FiniteDimensional K { x // x ∈ t }
⊢ finrank K { x // x ∈ s ⊔ t } ≤ finrank K { x // x ∈ s ⊔ t } + finrank K { x // x ∈ s ⊓ t }
[PROOFSTEP]
exact self_le_add_right _ _
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s t : Submodule K V
hdim : finrank K { x // x ∈ s } + finrank K { x // x ∈ t } = finrank K V
hdisjoint : Disjoint s t
⊢ s ⊔ t = ⊤
[PROOFSTEP]
have h_finrank_inf : finrank K ↑(s ⊓ t) = 0 :=
  by
  rw [disjoint_iff_inf_le, le_bot_iff] at hdisjoint 
  rw [hdisjoint, finrank_bot]
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s t : Submodule K V
hdim : finrank K { x // x ∈ s } + finrank K { x // x ∈ t } = finrank K V
hdisjoint : Disjoint s t
⊢ finrank K { x // x ∈ s ⊓ t } = 0
[PROOFSTEP]
rw [disjoint_iff_inf_le, le_bot_iff] at hdisjoint 
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s t : Submodule K V
hdim : finrank K { x // x ∈ s } + finrank K { x // x ∈ t } = finrank K V
hdisjoint : s ⊓ t = ⊥
⊢ finrank K { x // x ∈ s ⊓ t } = 0
[PROOFSTEP]
rw [hdisjoint, finrank_bot]
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s t : Submodule K V
hdim : finrank K { x // x ∈ s } + finrank K { x // x ∈ t } = finrank K V
hdisjoint : Disjoint s t
h_finrank_inf : finrank K { x // x ∈ s ⊓ t } = 0
⊢ s ⊔ t = ⊤
[PROOFSTEP]
apply eq_top_of_finrank_eq
[GOAL]
case h
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s t : Submodule K V
hdim : finrank K { x // x ∈ s } + finrank K { x // x ∈ t } = finrank K V
hdisjoint : Disjoint s t
h_finrank_inf : finrank K { x // x ∈ s ⊓ t } = 0
⊢ finrank K { x // x ∈ s ⊔ t } = finrank K V
[PROOFSTEP]
rw [← hdim]
[GOAL]
case h
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s t : Submodule K V
hdim : finrank K { x // x ∈ s } + finrank K { x // x ∈ t } = finrank K V
hdisjoint : Disjoint s t
h_finrank_inf : finrank K { x // x ∈ s ⊓ t } = 0
⊢ finrank K { x // x ∈ s ⊔ t } = finrank K { x // x ∈ s } + finrank K { x // x ∈ t }
[PROOFSTEP]
convert s.finrank_sup_add_finrank_inf_eq t
[GOAL]
case h.e'_2
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s t : Submodule K V
hdim : finrank K { x // x ∈ s } + finrank K { x // x ∈ t } = finrank K V
hdisjoint : Disjoint s t
h_finrank_inf : finrank K { x // x ∈ s ⊓ t } = 0
⊢ finrank K { x // x ∈ s ⊔ t } = finrank K { x // x ∈ s ⊔ t } + finrank K { x // x ∈ s ⊓ t }
[PROOFSTEP]
rw [h_finrank_inf]
[GOAL]
case h.e'_2
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s t : Submodule K V
hdim : finrank K { x // x ∈ s } + finrank K { x // x ∈ t } = finrank K V
hdisjoint : Disjoint s t
h_finrank_inf : finrank K { x // x ∈ s ⊓ t } = 0
⊢ finrank K { x // x ∈ s ⊔ t } = finrank K { x // x ∈ s ⊔ t } + 0
[PROOFSTEP]
rfl
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
S₁ S₂ : Submodule K V
inst✝ : FiniteDimensional K { x // x ∈ S₂ }
hle : S₁ ≤ S₂
hd : finrank K { x // x ∈ S₂ } ≤ finrank K { x // x ∈ S₁ }
⊢ S₁ = S₂
[PROOFSTEP]
rw [← LinearEquiv.finrank_eq (Submodule.comapSubtypeEquivOfLe hle)] at hd 
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
S₁ S₂ : Submodule K V
inst✝ : FiniteDimensional K { x // x ∈ S₂ }
hle : S₁ ≤ S₂
hd : finrank K { x // x ∈ S₂ } ≤ finrank K { x // x ∈ comap (Submodule.subtype S₂) S₁ }
⊢ S₁ = S₂
[PROOFSTEP]
exact
  le_antisymm hle
    (Submodule.comap_subtype_eq_top.1
      (eq_top_of_finrank_eq (le_antisymm (comap (Submodule.subtype S₂) S₁).finrank_le hd)))
[GOAL]
K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : FiniteDimensional K V
inst✝ : FiniteDimensional K V₂
p : Subspace K V
q : Subspace K V₂
f₁ : { x // x ∈ p } ≃ₗ[K] { x // x ∈ q }
f₂ : V ≃ₗ[K] V₂
⊢ finrank K (V ⧸ p) = finrank K (V₂ ⧸ q)
[PROOFSTEP]
rw [← @add_right_cancel_iff _ _ _ (finrank K p), Submodule.finrank_quotient_add_finrank, LinearEquiv.finrank_eq f₁,
  Submodule.finrank_quotient_add_finrank, LinearEquiv.finrank_eq f₂]
[GOAL]
K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : FiniteDimensional K V
inst✝ : FiniteDimensional K V₂
p q : Subspace K V
f : (V ⧸ p) ≃ₗ[K] { x // x ∈ q }
⊢ finrank K (V ⧸ q) + ?m.798563 f = finrank K { x // x ∈ p } + ?m.798563 f
[PROOFSTEP]
rw [Submodule.finrank_quotient_add_finrank, ← LinearEquiv.finrank_eq f, add_comm,
  Submodule.finrank_quotient_add_finrank]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
f : V →ₗ[K] V
hinj : Injective ↑f
⊢ Surjective ↑f
[PROOFSTEP]
have h := rank_range_of_injective _ hinj
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
f : V →ₗ[K] V
hinj : Injective ↑f
h : Module.rank K { x // x ∈ range f } = Module.rank K V
⊢ Surjective ↑f
[PROOFSTEP]
rw [← finrank_eq_rank, ← finrank_eq_rank, natCast_inj] at h 
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
f : V →ₗ[K] V
hinj : Injective ↑f
h : finrank K { x // x ∈ range f } = finrank K V
⊢ Surjective ↑f
[PROOFSTEP]
exact range_eq_top.1 (eq_top_of_finrank_eq h)
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
f : V →ₗ[K] V
⊢ ker f = ⊥ ↔ range f = ⊤
[PROOFSTEP]
rw [range_eq_top, ker_eq_bot, injective_iff_surjective]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
f g : V →ₗ[K] V
hfg : f * g = 1
⊢ g * f = 1
[PROOFSTEP]
have ginj : Injective g := HasLeftInverse.injective ⟨f, fun x => show (f * g) x = (1 : V →ₗ[K] V) x by rw [hfg]⟩
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
f g : V →ₗ[K] V
hfg : f * g = 1
x : V
⊢ ↑(f * g) x = ↑1 x
[PROOFSTEP]
rw [hfg]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
f g : V →ₗ[K] V
hfg : f * g = 1
ginj : Injective ↑g
⊢ g * f = 1
[PROOFSTEP]
let ⟨i, hi⟩ := g.exists_rightInverse_of_surjective (range_eq_top.2 (injective_iff_surjective.1 ginj))
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
f g : V →ₗ[K] V
hfg : f * g = 1
ginj : Injective ↑g
i : V →ₗ[K] V
hi : comp g i = id
⊢ g * f = 1
[PROOFSTEP]
have : f * (g * i) = f * 1 := congr_arg _ hi
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
f g : V →ₗ[K] V
hfg : f * g = 1
ginj : Injective ↑g
i : V →ₗ[K] V
hi : comp g i = id
this : f * (g * i) = f * 1
⊢ g * f = 1
[PROOFSTEP]
rw [← mul_assoc, hfg, one_mul, mul_one] at this 
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
f g : V →ₗ[K] V
hfg : f * g = 1
ginj : Injective ↑g
i : V →ₗ[K] V
hi : comp g i = id
this : i = f
⊢ g * f = 1
[PROOFSTEP]
rwa [← this]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
f : V →ₗ[K] V₂
⊢ finrank K { x // x ∈ range f } + finrank K { x // x ∈ ker f } = finrank K V
[PROOFSTEP]
rw [← f.quotKerEquivRange.finrank_eq]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
f : V →ₗ[K] V₂
⊢ finrank K (V ⧸ ker f) + finrank K { x // x ∈ ker f } = finrank K V
[PROOFSTEP]
exact Submodule.finrank_quotient_add_finrank _
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : V →ₗ[K] V
⊢ IsUnit f ↔ ker f = ⊥
[PROOFSTEP]
constructor
[GOAL]
case mp
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : V →ₗ[K] V
⊢ IsUnit f → ker f = ⊥
[PROOFSTEP]
rintro ⟨u, rfl⟩
[GOAL]
case mp.intro
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
u : (V →ₗ[K] V)ˣ
⊢ ker ↑u = ⊥
[PROOFSTEP]
exact LinearMap.ker_eq_bot_of_inverse u.inv_mul
[GOAL]
case mpr
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : V →ₗ[K] V
⊢ ker f = ⊥ → IsUnit f
[PROOFSTEP]
intro h_inj
[GOAL]
case mpr
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : V →ₗ[K] V
h_inj : ker f = ⊥
⊢ IsUnit f
[PROOFSTEP]
rw [ker_eq_bot] at h_inj 
[GOAL]
case mpr
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : V →ₗ[K] V
h_inj : Injective ↑f
⊢ IsUnit f
[PROOFSTEP]
exact
  ⟨⟨f, (LinearEquiv.ofInjectiveEndo f h_inj).symm.toLinearMap, LinearEquiv.ofInjectiveEndo_right_inv f h_inj,
      LinearEquiv.ofInjectiveEndo_left_inv f h_inj⟩,
    rfl⟩
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : V →ₗ[K] V
⊢ IsUnit f ↔ range f = ⊤
[PROOFSTEP]
rw [isUnit_iff_ker_eq_bot, ker_eq_bot_iff_range_eq_top]
[GOAL]
K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : FiniteDimensional K V
inst✝ : FiniteDimensional K V₂
H : finrank K V = finrank K V₂
f : V →ₗ[K] V₂
⊢ Injective ↑f ↔ Surjective ↑f
[PROOFSTEP]
have := finrank_range_add_finrank_ker f
[GOAL]
K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : FiniteDimensional K V
inst✝ : FiniteDimensional K V₂
H : finrank K V = finrank K V₂
f : V →ₗ[K] V₂
this : finrank K { x // x ∈ range f } + finrank K { x // x ∈ ker f } = finrank K V
⊢ Injective ↑f ↔ Surjective ↑f
[PROOFSTEP]
rw [← ker_eq_bot, ← range_eq_top]
[GOAL]
K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : FiniteDimensional K V
inst✝ : FiniteDimensional K V₂
H : finrank K V = finrank K V₂
f : V →ₗ[K] V₂
this : finrank K { x // x ∈ range f } + finrank K { x // x ∈ ker f } = finrank K V
⊢ ker f = ⊥ ↔ range f = ⊤
[PROOFSTEP]
refine' ⟨fun h => _, fun h => _⟩
[GOAL]
case refine'_1
K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : FiniteDimensional K V
inst✝ : FiniteDimensional K V₂
H : finrank K V = finrank K V₂
f : V →ₗ[K] V₂
this : finrank K { x // x ∈ range f } + finrank K { x // x ∈ ker f } = finrank K V
h : ker f = ⊥
⊢ range f = ⊤
[PROOFSTEP]
rw [h, finrank_bot, add_zero, H] at this 
[GOAL]
case refine'_1
K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : FiniteDimensional K V
inst✝ : FiniteDimensional K V₂
H : finrank K V = finrank K V₂
f : V →ₗ[K] V₂
this : finrank K { x // x ∈ range f } = finrank K V₂
h : ker f = ⊥
⊢ range f = ⊤
[PROOFSTEP]
exact eq_top_of_finrank_eq this
[GOAL]
case refine'_2
K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : FiniteDimensional K V
inst✝ : FiniteDimensional K V₂
H : finrank K V = finrank K V₂
f : V →ₗ[K] V₂
this : finrank K { x // x ∈ range f } + finrank K { x // x ∈ ker f } = finrank K V
h : range f = ⊤
⊢ ker f = ⊥
[PROOFSTEP]
rw [h, finrank_top, H] at this 
[GOAL]
case refine'_2
K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : FiniteDimensional K V
inst✝ : FiniteDimensional K V₂
H : finrank K V = finrank K V₂
f : V →ₗ[K] V₂
this : finrank K V₂ + finrank K { x // x ∈ ker f } = finrank K V₂
h : range f = ⊤
⊢ ker f = ⊥
[PROOFSTEP]
exact finrank_eq_zero.1 (add_right_injective _ this)
[GOAL]
K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : FiniteDimensional K V
inst✝ : FiniteDimensional K V₂
H : finrank K V = finrank K V₂
f : V →ₗ[K] V₂
⊢ ker f = ⊥ ↔ range f = ⊤
[PROOFSTEP]
rw [range_eq_top, ker_eq_bot, injective_iff_surjective_of_finrank_eq_finrank H]
[GOAL]
K✝ : Type u
V : Type v
F : Type u_1
K : Type u_2
inst✝⁴ : Field F
inst✝³ : Ring K
inst✝² : IsDomain K
inst✝¹ : Algebra F K
inst✝ : FiniteDimensional F K
x : K
H : x ≠ 0
⊢ ∃ y, x * y = 1
[PROOFSTEP]
have : Function.Surjective (LinearMap.mulLeft F x) :=
  LinearMap.injective_iff_surjective.1 fun y z => ((mul_right_inj' H).1 : x * y = x * z → y = z)
[GOAL]
K✝ : Type u
V : Type v
F : Type u_1
K : Type u_2
inst✝⁴ : Field F
inst✝³ : Ring K
inst✝² : IsDomain K
inst✝¹ : Algebra F K
inst✝ : FiniteDimensional F K
x : K
H : x ≠ 0
this : Surjective ↑(LinearMap.mulLeft F x)
⊢ ∃ y, x * y = 1
[PROOFSTEP]
exact this 1
[GOAL]
K✝ : Type u
V : Type v
F : Type u_1
K : Type u_2
inst✝³ : Field F
h : Ring K
inst✝² : IsDomain K
inst✝¹ : Algebra F K
inst✝ : FiniteDimensional F K
src✝ : IsDomain K := inst✝²
x : K
hx : x ≠ 0
⊢ (x * if H : x = 0 then 0 else Classical.choose (_ : ∃ y, x * y = 1)) = 1
[PROOFSTEP]
rw [dif_neg hx]
[GOAL]
K✝ : Type u
V : Type v
F : Type u_1
K : Type u_2
inst✝³ : Field F
h : Ring K
inst✝² : IsDomain K
inst✝¹ : Algebra F K
inst✝ : FiniteDimensional F K
src✝ : IsDomain K := inst✝²
x : K
hx : x ≠ 0
⊢ x * Classical.choose (_ : ∃ y, x * y = 1) = 1
[PROOFSTEP]
exact (Classical.choose_spec (FiniteDimensional.exists_mul_eq_one F hx) :)
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
U W : Submodule K V
h : IsCompl U W
⊢ finrank K { x // x ∈ U } + finrank K { x // x ∈ W } = finrank K V
[PROOFSTEP]
rw [← finrank_sup_add_finrank_inf_eq, h.codisjoint.eq_top, h.disjoint.eq_bot, finrank_bot, add_zero]
[GOAL]
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
U W : Submodule K V
h : IsCompl U W
⊢ finrank K { x // x ∈ ⊤ } = finrank K V
[PROOFSTEP]
exact finrank_top _ _
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
hv : v ≠ 0
⊢ finrank K { x // x ∈ span K {v} } = 1
[PROOFSTEP]
apply le_antisymm
[GOAL]
case a
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
hv : v ≠ 0
⊢ finrank K { x // x ∈ span K {v} } ≤ 1
[PROOFSTEP]
exact finrank_span_le_card ({ v } : Set V)
[GOAL]
case a
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
hv : v ≠ 0
⊢ 1 ≤ finrank K { x // x ∈ span K {v} }
[PROOFSTEP]
rw [Nat.succ_le_iff, finrank_pos_iff]
[GOAL]
case a
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
hv : v ≠ 0
⊢ Nontrivial { x // x ∈ span K {v} }
[PROOFSTEP]
use⟨v, mem_span_singleton_self v⟩, 0
[GOAL]
case h
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
hv : v ≠ 0
⊢ { val := v, property := (_ : v ∈ span K {v}) } ≠ 0
[PROOFSTEP]
simp [hv]
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : finrank K V = 1
x : V
hx : x ≠ 0
y : V
⊢ ∃ c, c • x = y
[PROOFSTEP]
have : Submodule.span K { x } = ⊤ :=
  by
  have : FiniteDimensional K V := finiteDimensional_of_finrank (zero_lt_one.trans_le h.symm.le)
  apply eq_top_of_finrank_eq
  rw [h]
  exact finrank_span_singleton hx
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : finrank K V = 1
x : V
hx : x ≠ 0
y : V
⊢ span K {x} = ⊤
[PROOFSTEP]
have : FiniteDimensional K V := finiteDimensional_of_finrank (zero_lt_one.trans_le h.symm.le)
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : finrank K V = 1
x : V
hx : x ≠ 0
y : V
this : FiniteDimensional K V
⊢ span K {x} = ⊤
[PROOFSTEP]
apply eq_top_of_finrank_eq
[GOAL]
case h
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : finrank K V = 1
x : V
hx : x ≠ 0
y : V
this : FiniteDimensional K V
⊢ finrank K { x_1 // x_1 ∈ span K {x} } = finrank K V
[PROOFSTEP]
rw [h]
[GOAL]
case h
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : finrank K V = 1
x : V
hx : x ≠ 0
y : V
this : FiniteDimensional K V
⊢ finrank K { x_1 // x_1 ∈ span K {x} } = 1
[PROOFSTEP]
exact finrank_span_singleton hx
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : finrank K V = 1
x : V
hx : x ≠ 0
y : V
this : span K {x} = ⊤
⊢ ∃ c, c • x = y
[PROOFSTEP]
have : y ∈ Submodule.span K { x } := by rw [this]; trivial
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : finrank K V = 1
x : V
hx : x ≠ 0
y : V
this : span K {x} = ⊤
⊢ y ∈ span K {x}
[PROOFSTEP]
rw [this]
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : finrank K V = 1
x : V
hx : x ≠ 0
y : V
this : span K {x} = ⊤
⊢ y ∈ ⊤
[PROOFSTEP]
trivial
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : finrank K V = 1
x : V
hx : x ≠ 0
y : V
this✝ : span K {x} = ⊤
this : y ∈ span K {x}
⊢ ∃ c, c • x = y
[PROOFSTEP]
exact mem_span_singleton.1 this
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
hι : Nonempty ι
inst✝ : Fintype ι
b : ι → V
lin_ind : LinearIndependent K b
card_eq : Fintype.card ι = finrank K V
⊢ span K (Set.range b) = ⊤
[PROOFSTEP]
by_cases fin : FiniteDimensional K V
[GOAL]
case pos
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
hι : Nonempty ι
inst✝ : Fintype ι
b : ι → V
lin_ind : LinearIndependent K b
card_eq : Fintype.card ι = finrank K V
fin : FiniteDimensional K V
⊢ span K (Set.range b) = ⊤
[PROOFSTEP]
replace fin : FiniteDimensional _ _ := fin
[GOAL]
case pos
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
hι : Nonempty ι
inst✝ : Fintype ι
b : ι → V
lin_ind : LinearIndependent K b
card_eq : Fintype.card ι = finrank K V
fin : FiniteDimensional K V
⊢ span K (Set.range b) = ⊤
[PROOFSTEP]
by_contra ne_top
[GOAL]
case pos
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
hι : Nonempty ι
inst✝ : Fintype ι
b : ι → V
lin_ind : LinearIndependent K b
card_eq : Fintype.card ι = finrank K V
fin : FiniteDimensional K V
ne_top : ¬span K (Set.range b) = ⊤
⊢ False
[PROOFSTEP]
have lt_top : span K (Set.range b) < ⊤ := lt_of_le_of_ne le_top ne_top
[GOAL]
case pos
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
hι : Nonempty ι
inst✝ : Fintype ι
b : ι → V
lin_ind : LinearIndependent K b
card_eq : Fintype.card ι = finrank K V
fin : FiniteDimensional K V
ne_top : ¬span K (Set.range b) = ⊤
lt_top : span K (Set.range b) < ⊤
⊢ False
[PROOFSTEP]
exact ne_of_lt (Submodule.finrank_lt lt_top) (_root_.trans (finrank_span_eq_card lin_ind) card_eq)
[GOAL]
case neg
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
hι : Nonempty ι
inst✝ : Fintype ι
b : ι → V
lin_ind : LinearIndependent K b
card_eq : Fintype.card ι = finrank K V
fin : ¬FiniteDimensional K V
⊢ span K (Set.range b) = ⊤
[PROOFSTEP]
exfalso
[GOAL]
case neg.h
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
hι : Nonempty ι
inst✝ : Fintype ι
b : ι → V
lin_ind : LinearIndependent K b
card_eq : Fintype.card ι = finrank K V
fin : ¬FiniteDimensional K V
⊢ False
[PROOFSTEP]
apply ne_of_lt (Fintype.card_pos_iff.mpr hι)
[GOAL]
case neg.h
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
hι : Nonempty ι
inst✝ : Fintype ι
b : ι → V
lin_ind : LinearIndependent K b
card_eq : Fintype.card ι = finrank K V
fin : ¬FiniteDimensional K V
⊢ 0 = Fintype.card ι
[PROOFSTEP]
symm
[GOAL]
case neg.h
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
hι : Nonempty ι
inst✝ : Fintype ι
b : ι → V
lin_ind : LinearIndependent K b
card_eq : Fintype.card ι = finrank K V
fin : ¬FiniteDimensional K V
⊢ Fintype.card ι = 0
[PROOFSTEP]
replace fin := (not_iff_not.2 IsNoetherian.iff_fg).2 fin
[GOAL]
case neg.h
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
hι : Nonempty ι
inst✝ : Fintype ι
b : ι → V
lin_ind : LinearIndependent K b
card_eq : Fintype.card ι = finrank K V
fin : ¬IsNoetherian K V
⊢ Fintype.card ι = 0
[PROOFSTEP]
calc
  Fintype.card ι = finrank K V := card_eq
  _ = 0 := dif_neg (mt IsNoetherian.iff_rank_lt_aleph0.mpr fin)
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
s : Finset V
hs : Finset.Nonempty s
lin_ind : LinearIndependent K Subtype.val
card_eq : Finset.card s = finrank K V
⊢ ↑(finsetBasisOfLinearIndependentOfCardEqFinrank hs lin_ind card_eq) = Subtype.val
[PROOFSTEP]
rw [finsetBasisOfLinearIndependentOfCardEqFinrank]
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
s : Finset V
hs : Finset.Nonempty s
lin_ind : LinearIndependent K Subtype.val
card_eq : Finset.card s = finrank K V
⊢ ↑(basisOfLinearIndependentOfCardEqFinrank lin_ind (_ : Fintype.card { x // x ∈ s } = finrank K V)) = Subtype.val
[PROOFSTEP]
exact Basis.coe_mk _ _
[GOAL]
K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s : Set V
inst✝¹ : Nonempty ↑s
inst✝ : Fintype ↑s
lin_ind : LinearIndependent K Subtype.val
card_eq : Finset.card (Set.toFinset s) = finrank K V
⊢ ↑(setBasisOfLinearIndependentOfCardEqFinrank lin_ind card_eq) = Subtype.val
[PROOFSTEP]
rw [setBasisOfLinearIndependentOfCardEqFinrank]
[GOAL]
K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s : Set V
inst✝¹ : Nonempty ↑s
inst✝ : Fintype ↑s
lin_ind : LinearIndependent K Subtype.val
card_eq : Finset.card (Set.toFinset s) = finrank K V
⊢ ↑(basisOfLinearIndependentOfCardEqFinrank lin_ind (_ : Fintype.card ↑s = finrank K V)) = Subtype.val
[PROOFSTEP]
exact Basis.coe_mk _ _
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
nz : v ≠ 0
h : finrank K V = 1
⊢ span K {v} = ⊤
[PROOFSTEP]
simpa using (basisSingleton PUnit.{u + 1} h v nz).span_eq
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
nz : v ≠ 0
s : span K {v} = ⊤
⊢ ⊤ ≤ span K (Set.range fun x => ↑x)
[PROOFSTEP]
convert s.ge
[GOAL]
case h.e'_4.h.e'_6
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
nz : v ≠ 0
s : span K {v} = ⊤
⊢ (Set.range fun x => ↑x) = {v}
[PROOFSTEP]
simp
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
nz : v ≠ 0
⊢ finrank K V = 1 ↔ ∀ (w : V), ∃ c, c • v = w
[PROOFSTEP]
rw [finrank_eq_one_iff_of_nonzero v nz]
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
nz : v ≠ 0
⊢ span K {v} = ⊤ ↔ ∀ (w : V), ∃ c, c • v = w
[PROOFSTEP]
apply span_singleton_eq_top_iff
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Unique ι
⊢ finrank K V = 1 ↔ Nonempty (Basis ι K V)
[PROOFSTEP]
constructor
[GOAL]
case mp
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Unique ι
⊢ finrank K V = 1 → Nonempty (Basis ι K V)
[PROOFSTEP]
intro h
[GOAL]
case mp
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Unique ι
h : finrank K V = 1
⊢ Nonempty (Basis ι K V)
[PROOFSTEP]
haveI := finiteDimensional_of_finrank (_root_.zero_lt_one.trans_le h.symm.le)
[GOAL]
case mp
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Unique ι
h : finrank K V = 1
this : FiniteDimensional K V
⊢ Nonempty (Basis ι K V)
[PROOFSTEP]
exact ⟨basisUnique ι h⟩
[GOAL]
case mpr
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Unique ι
⊢ Nonempty (Basis ι K V) → finrank K V = 1
[PROOFSTEP]
rintro ⟨b⟩
[GOAL]
case mpr.intro
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
ι : Type u_1
inst✝ : Unique ι
b : Basis ι K V
⊢ finrank K V = 1
[PROOFSTEP]
simpa using finrank_eq_card_basis b
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
⊢ finrank K V = 1 ↔ ∃ v _n, ∀ (w : V), ∃ c, c • v = w
[PROOFSTEP]
rw [finrank_eq_one_iff PUnit.{u + 1}, Basis.basis_singleton_iff PUnit]
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
⊢ finrank K V ≤ 1 ↔ ∃ v, ∀ (w : V), ∃ c, c • v = w
[PROOFSTEP]
constructor
[GOAL]
case mp
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
⊢ finrank K V ≤ 1 → ∃ v, ∀ (w : V), ∃ c, c • v = w
[PROOFSTEP]
intro h
[GOAL]
case mp
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
h : finrank K V ≤ 1
⊢ ∃ v, ∀ (w : V), ∃ c, c • v = w
[PROOFSTEP]
by_cases h' : finrank K V = 0
[GOAL]
case pos
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
h : finrank K V ≤ 1
h' : finrank K V = 0
⊢ ∃ v, ∀ (w : V), ∃ c, c • v = w
[PROOFSTEP]
use 0
[GOAL]
case h
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
h : finrank K V ≤ 1
h' : finrank K V = 0
⊢ ∀ (w : V), ∃ c, c • 0 = w
[PROOFSTEP]
intro w
[GOAL]
case h
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
h : finrank K V ≤ 1
h' : finrank K V = 0
w : V
⊢ ∃ c, c • 0 = w
[PROOFSTEP]
use 0
[GOAL]
case h
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
h : finrank K V ≤ 1
h' : finrank K V = 0
w : V
⊢ 0 • 0 = w
[PROOFSTEP]
haveI := finrank_zero_iff.mp h'
[GOAL]
case h
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
h : finrank K V ≤ 1
h' : finrank K V = 0
w : V
this : Subsingleton V
⊢ 0 • 0 = w
[PROOFSTEP]
apply Subsingleton.elim
[GOAL]
case neg
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
h : finrank K V ≤ 1
h' : ¬finrank K V = 0
⊢ ∃ v, ∀ (w : V), ∃ c, c • v = w
[PROOFSTEP]
replace h' := zero_lt_iff.mpr h'
[GOAL]
case neg
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
h : finrank K V ≤ 1
h' : 0 < finrank K V
⊢ ∃ v, ∀ (w : V), ∃ c, c • v = w
[PROOFSTEP]
have : finrank K V = 1 := by linarith
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
h : finrank K V ≤ 1
h' : 0 < finrank K V
⊢ finrank K V = 1
[PROOFSTEP]
linarith
[GOAL]
case neg
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
h : finrank K V ≤ 1
h' : 0 < finrank K V
this : finrank K V = 1
⊢ ∃ v, ∀ (w : V), ∃ c, c • v = w
[PROOFSTEP]
obtain ⟨v, -, p⟩ := finrank_eq_one_iff'.mp this
[GOAL]
case neg.intro.intro
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
h : finrank K V ≤ 1
h' : 0 < finrank K V
this : finrank K V = 1
v : V
p : ∀ (w : V), ∃ c, c • v = w
⊢ ∃ v, ∀ (w : V), ∃ c, c • v = w
[PROOFSTEP]
use v, p
[GOAL]
case mpr
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
⊢ (∃ v, ∀ (w : V), ∃ c, c • v = w) → finrank K V ≤ 1
[PROOFSTEP]
rintro ⟨v, p⟩
[GOAL]
case mpr.intro
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
v : V
p : ∀ (w : V), ∃ c, c • v = w
⊢ finrank K V ≤ 1
[PROOFSTEP]
exact finrank_le_one v p
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
W : Submodule K V
inst✝ : FiniteDimensional K { x // x ∈ W }
⊢ finrank K { x // x ∈ W } ≤ 1 ↔ IsPrincipal W
[PROOFSTEP]
rw [← W.rank_le_one_iff_isPrincipal, ← finrank_eq_rank, ← Cardinal.natCast_le, Nat.cast_one]
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
⊢ finrank K V ≤ 1 ↔ IsPrincipal ⊤
[PROOFSTEP]
rw [← Module.rank_le_one_iff_top_isPrincipal, ← finrank_eq_rank, ← Cardinal.natCast_le, Nat.cast_one]
[GOAL]
K : Type u
V : Type v
inst✝⁸ : DivisionRing K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
W : Type u_1
A : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : Module A V
inst✝³ : AddCommGroup W
inst✝² : Module K W
inst✝¹ : Module A W
inst✝ : LinearMap.CompatibleSMul V W K A
h : finrank K W = 1
f : V →ₗ[A] W
w : f ≠ 0
⊢ Surjective ↑f
[PROOFSTEP]
change Surjective (f.restrictScalars K)
[GOAL]
K : Type u
V : Type v
inst✝⁸ : DivisionRing K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
W : Type u_1
A : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : Module A V
inst✝³ : AddCommGroup W
inst✝² : Module K W
inst✝¹ : Module A W
inst✝ : LinearMap.CompatibleSMul V W K A
h : finrank K W = 1
f : V →ₗ[A] W
w : f ≠ 0
⊢ Surjective ↑(↑K f)
[PROOFSTEP]
obtain ⟨v, n⟩ := FunLike.ne_iff.mp w
[GOAL]
case intro
K : Type u
V : Type v
inst✝⁸ : DivisionRing K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
W : Type u_1
A : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : Module A V
inst✝³ : AddCommGroup W
inst✝² : Module K W
inst✝¹ : Module A W
inst✝ : LinearMap.CompatibleSMul V W K A
h : finrank K W = 1
f : V →ₗ[A] W
w : f ≠ 0
v : V
n : ↑f v ≠ ↑0 v
⊢ Surjective ↑(↑K f)
[PROOFSTEP]
intro z
[GOAL]
case intro
K : Type u
V : Type v
inst✝⁸ : DivisionRing K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
W : Type u_1
A : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : Module A V
inst✝³ : AddCommGroup W
inst✝² : Module K W
inst✝¹ : Module A W
inst✝ : LinearMap.CompatibleSMul V W K A
h : finrank K W = 1
f : V →ₗ[A] W
w : f ≠ 0
v : V
n : ↑f v ≠ ↑0 v
z : W
⊢ ∃ a, ↑(↑K f) a = z
[PROOFSTEP]
obtain ⟨c, rfl⟩ := (finrank_eq_one_iff_of_nonzero' (f v) n).mp h z
[GOAL]
case intro.intro
K : Type u
V : Type v
inst✝⁸ : DivisionRing K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
W : Type u_1
A : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : Module A V
inst✝³ : AddCommGroup W
inst✝² : Module K W
inst✝¹ : Module A W
inst✝ : LinearMap.CompatibleSMul V W K A
h : finrank K W = 1
f : V →ₗ[A] W
w : f ≠ 0
v : V
n : ↑f v ≠ ↑0 v
c : K
⊢ ∃ a, ↑(↑K f) a = c • ↑f v
[PROOFSTEP]
exact ⟨c • v, by simp⟩
[GOAL]
K : Type u
V : Type v
inst✝⁸ : DivisionRing K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
W : Type u_1
A : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : Module A V
inst✝³ : AddCommGroup W
inst✝² : Module K W
inst✝¹ : Module A W
inst✝ : LinearMap.CompatibleSMul V W K A
h : finrank K W = 1
f : V →ₗ[A] W
w : f ≠ 0
v : V
n : ↑f v ≠ ↑0 v
c : K
⊢ ↑(↑K f) (c • v) = c • ↑f v
[PROOFSTEP]
simp
[GOAL]
K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
A : Type u_1
inst✝³ : Semiring A
inst✝² : Module A V
inst✝¹ : SMul K A
inst✝ : IsScalarTower K A V
h : finrank K V = 1
⊢ IsSimpleOrder (Submodule A V)
[PROOFSTEP]
haveI := nontrivial_of_finrank_eq_succ h
[GOAL]
K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
A : Type u_1
inst✝³ : Semiring A
inst✝² : Module A V
inst✝¹ : SMul K A
inst✝ : IsScalarTower K A V
h : finrank K V = 1
this : Nontrivial V
⊢ IsSimpleOrder (Submodule A V)
[PROOFSTEP]
refine' ⟨fun S => or_iff_not_imp_left.2 fun hn => _⟩
[GOAL]
K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
A : Type u_1
inst✝³ : Semiring A
inst✝² : Module A V
inst✝¹ : SMul K A
inst✝ : IsScalarTower K A V
h : finrank K V = 1
this : Nontrivial V
S : Submodule A V
hn : ¬S = ⊥
⊢ S = ⊤
[PROOFSTEP]
rw [← restrictScalars_inj K] at hn ⊢
[GOAL]
K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
A : Type u_1
inst✝³ : Semiring A
inst✝² : Module A V
inst✝¹ : SMul K A
inst✝ : IsScalarTower K A V
h : finrank K V = 1
this : Nontrivial V
S : Submodule A V
hn : ¬restrictScalars K S = restrictScalars K ⊥
⊢ restrictScalars K S = restrictScalars K ⊤
[PROOFSTEP]
haveI : FiniteDimensional _ _ := finiteDimensional_of_finrank_eq_succ h
[GOAL]
K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
A : Type u_1
inst✝³ : Semiring A
inst✝² : Module A V
inst✝¹ : SMul K A
inst✝ : IsScalarTower K A V
h : finrank K V = 1
this✝ : Nontrivial V
S : Submodule A V
hn : ¬restrictScalars K S = restrictScalars K ⊥
this : FiniteDimensional K V
⊢ restrictScalars K S = restrictScalars K ⊤
[PROOFSTEP]
refine' eq_top_of_finrank_eq ((Submodule.finrank_le _).antisymm _)
[GOAL]
K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
A : Type u_1
inst✝³ : Semiring A
inst✝² : Module A V
inst✝¹ : SMul K A
inst✝ : IsScalarTower K A V
h : finrank K V = 1
this✝ : Nontrivial V
S : Submodule A V
hn : ¬restrictScalars K S = restrictScalars K ⊥
this : FiniteDimensional K V
⊢ finrank K V ≤ finrank K { x // x ∈ restrictScalars K S }
[PROOFSTEP]
simpa only [h, finrank_bot] using Submodule.finrank_strictMono (Ne.bot_lt hn)
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
⊢ FiniteDimensional F { x // x ∈ ⊥ }
[PROOFSTEP]
nontriviality E
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
✝ : Nontrivial E
⊢ FiniteDimensional F { x // x ∈ ⊥ }
[PROOFSTEP]
exact finiteDimensional_of_rank_eq_one Subalgebra.rank_bot
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
S : Subalgebra F E
h : Module.rank F { x // x ∈ S } ≤ 1
⊢ S = ⊥
[PROOFSTEP]
nontriviality E
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
S : Subalgebra F E
h : Module.rank F { x // x ∈ S } ≤ 1
✝ : Nontrivial E
⊢ S = ⊥
[PROOFSTEP]
obtain ⟨m, _, he⟩ :=
  Cardinal.exists_nat_eq_of_le_nat
    (h.trans_eq Nat.cast_one.symm)
      -- porting note: fails without explicit type
[GOAL]
case intro.intro
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
S : Subalgebra F E
h : Module.rank F { x // x ∈ S } ≤ 1
✝ : Nontrivial E
m : ℕ
left✝ : m ≤ 1
he : Module.rank F { x // x ∈ S } = ↑m
⊢ S = ⊥
[PROOFSTEP]
haveI : FiniteDimensional F S := finiteDimensional_of_rank_eq_nat he
[GOAL]
case intro.intro
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
S : Subalgebra F E
h : Module.rank F { x // x ∈ S } ≤ 1
✝ : Nontrivial E
m : ℕ
left✝ : m ≤ 1
he : Module.rank F { x // x ∈ S } = ↑m
this : FiniteDimensional F { x // x ∈ S }
⊢ S = ⊥
[PROOFSTEP]
rw [← not_bot_lt_iff, ← Subalgebra.toSubmodule.lt_iff_lt]
  -- porting note: fails without explicit type
[GOAL]
case intro.intro
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
S : Subalgebra F E
h : Module.rank F { x // x ∈ S } ≤ 1
✝ : Nontrivial E
m : ℕ
left✝ : m ≤ 1
he : Module.rank F { x // x ∈ S } = ↑m
this : FiniteDimensional F { x // x ∈ S }
⊢ ¬↑toSubmodule ⊥ < ↑toSubmodule S
[PROOFSTEP]
haveI : FiniteDimensional F (Subalgebra.toSubmodule S) := S.toSubmoduleEquiv.symm.finiteDimensional
[GOAL]
case intro.intro
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
S : Subalgebra F E
h : Module.rank F { x // x ∈ S } ≤ 1
✝ : Nontrivial E
m : ℕ
left✝ : m ≤ 1
he : Module.rank F { x // x ∈ S } = ↑m
this✝ : FiniteDimensional F { x // x ∈ S }
this : FiniteDimensional F { x // x ∈ ↑toSubmodule S }
⊢ ¬↑toSubmodule ⊥ < ↑toSubmodule S
[PROOFSTEP]
refine fun hl => (Submodule.finrank_lt_finrank_of_lt hl).not_le (natCast_le.1 ?_)
[GOAL]
case intro.intro
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
S : Subalgebra F E
h : Module.rank F { x // x ∈ S } ≤ 1
✝ : Nontrivial E
m : ℕ
left✝ : m ≤ 1
he : Module.rank F { x // x ∈ S } = ↑m
this✝ : FiniteDimensional F { x // x ∈ S }
this : FiniteDimensional F { x // x ∈ ↑toSubmodule S }
hl : ↑toSubmodule ⊥ < ↑toSubmodule S
⊢ ↑(finrank F { x // x ∈ ↑toSubmodule S }) ≤ ↑(finrank F { x // x ∈ ↑toSubmodule ⊥ })
[PROOFSTEP]
iterate 2 rw [Subalgebra.finrank_toSubmodule, finrank_eq_rank]
[GOAL]
case intro.intro
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
S : Subalgebra F E
h : Module.rank F { x // x ∈ S } ≤ 1
✝ : Nontrivial E
m : ℕ
left✝ : m ≤ 1
he : Module.rank F { x // x ∈ S } = ↑m
this✝ : FiniteDimensional F { x // x ∈ S }
this : FiniteDimensional F { x // x ∈ ↑toSubmodule S }
hl : ↑toSubmodule ⊥ < ↑toSubmodule S
⊢ ↑(finrank F { x // x ∈ ↑toSubmodule S }) ≤ ↑(finrank F { x // x ∈ ↑toSubmodule ⊥ })
[PROOFSTEP]
rw [Subalgebra.finrank_toSubmodule, finrank_eq_rank]
[GOAL]
case intro.intro
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
S : Subalgebra F E
h : Module.rank F { x // x ∈ S } ≤ 1
✝ : Nontrivial E
m : ℕ
left✝ : m ≤ 1
he : Module.rank F { x // x ∈ S } = ↑m
this✝ : FiniteDimensional F { x // x ∈ S }
this : FiniteDimensional F { x // x ∈ ↑toSubmodule S }
hl : ↑toSubmodule ⊥ < ↑toSubmodule S
⊢ Module.rank F { x // x ∈ S } ≤ ↑(finrank F { x // x ∈ ↑toSubmodule ⊥ })
[PROOFSTEP]
rw [Subalgebra.finrank_toSubmodule, finrank_eq_rank]
[GOAL]
case intro.intro
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
S : Subalgebra F E
h : Module.rank F { x // x ∈ S } ≤ 1
✝ : Nontrivial E
m : ℕ
left✝ : m ≤ 1
he : Module.rank F { x // x ∈ S } = ↑m
this✝ : FiniteDimensional F { x // x ∈ S }
this : FiniteDimensional F { x // x ∈ ↑toSubmodule S }
hl : ↑toSubmodule ⊥ < ↑toSubmodule S
⊢ Module.rank F { x // x ∈ S } ≤ Module.rank F { x // x ∈ ⊥ }
[PROOFSTEP]
exact h.trans_eq Subalgebra.rank_bot.symm
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
S : Subalgebra F E
h : finrank F { x // x ∈ S } = 1
⊢ Module.rank F { x // x ∈ S } ≤ 1
[PROOFSTEP]
haveI : FiniteDimensional F S := finiteDimensional_of_finrank_eq_succ h
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
S : Subalgebra F E
h : finrank F { x // x ∈ S } = 1
this : FiniteDimensional F { x // x ∈ S }
⊢ Module.rank F { x // x ∈ S } ≤ 1
[PROOFSTEP]
rw [← finrank_eq_rank, h, Nat.cast_one]
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝³ : Field F
inst✝² : Ring E
inst✝¹ : Algebra F E
inst✝ : Nontrivial E
⊢ ⊥ = ⊤ ↔ Module.rank F E = 1
[PROOFSTEP]
rw [← rank_top, Subalgebra.rank_eq_one_iff, eq_comm]
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝³ : Field F
inst✝² : Ring E
inst✝¹ : Algebra F E
inst✝ : Nontrivial E
⊢ ⊥ = ⊤ ↔ finrank F E = 1
[PROOFSTEP]
rw [← finrank_top, ← subalgebra_top_finrank_eq_submodule_top_finrank, Subalgebra.finrank_eq_one_iff, eq_comm]
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
hr : finrank F E = 2
i : Nontrivial E := nontrivial_of_finrank_pos (LT.lt.trans_eq zero_lt_two (Eq.symm hr))
h : ⊥ = ⊤
⊢ False
[PROOFSTEP]
cases hr.symm.trans (Subalgebra.bot_eq_top_iff_finrank_eq_one.1 h)
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
hr : finrank F E = 2
i : Nontrivial E := nontrivial_of_finrank_pos (LT.lt.trans_eq zero_lt_two (Eq.symm hr))
⊢ ∀ (a : Subalgebra F E), a = ⊥ ∨ a = ⊤
[PROOFSTEP]
intro S
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
hr : finrank F E = 2
i : Nontrivial E := nontrivial_of_finrank_pos (LT.lt.trans_eq zero_lt_two (Eq.symm hr))
S : Subalgebra F E
⊢ S = ⊥ ∨ S = ⊤
[PROOFSTEP]
haveI : FiniteDimensional F E := finiteDimensional_of_finrank_eq_succ hr
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
hr : finrank F E = 2
i : Nontrivial E := nontrivial_of_finrank_pos (LT.lt.trans_eq zero_lt_two (Eq.symm hr))
S : Subalgebra F E
this : FiniteDimensional F E
⊢ S = ⊥ ∨ S = ⊤
[PROOFSTEP]
haveI : FiniteDimensional F S := FiniteDimensional.finiteDimensional_submodule (Subalgebra.toSubmodule S)
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
hr : finrank F E = 2
i : Nontrivial E := nontrivial_of_finrank_pos (LT.lt.trans_eq zero_lt_two (Eq.symm hr))
S : Subalgebra F E
this✝ : FiniteDimensional F E
this : FiniteDimensional F { x // x ∈ S }
⊢ S = ⊥ ∨ S = ⊤
[PROOFSTEP]
have : finrank F S ≤ 2 := hr ▸ S.toSubmodule.finrank_le
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
hr : finrank F E = 2
i : Nontrivial E := nontrivial_of_finrank_pos (LT.lt.trans_eq zero_lt_two (Eq.symm hr))
S : Subalgebra F E
this✝¹ : FiniteDimensional F E
this✝ : FiniteDimensional F { x // x ∈ S }
this : finrank F { x // x ∈ S } ≤ 2
⊢ S = ⊥ ∨ S = ⊤
[PROOFSTEP]
have : 0 < finrank F S := finrank_pos_iff.mpr inferInstance
[GOAL]
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
hr : finrank F E = 2
i : Nontrivial E := nontrivial_of_finrank_pos (LT.lt.trans_eq zero_lt_two (Eq.symm hr))
S : Subalgebra F E
this✝² : FiniteDimensional F E
this✝¹ : FiniteDimensional F { x // x ∈ S }
this✝ : finrank F { x // x ∈ S } ≤ 2
this : 0 < finrank F { x // x ∈ S }
⊢ S = ⊥ ∨ S = ⊤
[PROOFSTEP]
interval_cases h : finrank F { x // x ∈ S }
[GOAL]
case «1»
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
hr : finrank F E = 2
i : Nontrivial E := nontrivial_of_finrank_pos (LT.lt.trans_eq zero_lt_two (Eq.symm hr))
S : Subalgebra F E
this✝² : FiniteDimensional F E
this✝¹ : FiniteDimensional F { x // x ∈ S }
h : finrank F { x // x ∈ S } = 1
this✝ : 1 ≤ 2
this : 0 < 1
⊢ S = ⊥ ∨ S = ⊤
[PROOFSTEP]
left
[GOAL]
case «1».h
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
hr : finrank F E = 2
i : Nontrivial E := nontrivial_of_finrank_pos (LT.lt.trans_eq zero_lt_two (Eq.symm hr))
S : Subalgebra F E
this✝² : FiniteDimensional F E
this✝¹ : FiniteDimensional F { x // x ∈ S }
h : finrank F { x // x ∈ S } = 1
this✝ : 1 ≤ 2
this : 0 < 1
⊢ S = ⊥
[PROOFSTEP]
exact Subalgebra.eq_bot_of_finrank_one h
[GOAL]
case «2»
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
hr : finrank F E = 2
i : Nontrivial E := nontrivial_of_finrank_pos (LT.lt.trans_eq zero_lt_two (Eq.symm hr))
S : Subalgebra F E
this✝² : FiniteDimensional F E
this✝¹ : FiniteDimensional F { x // x ∈ S }
h : finrank F { x // x ∈ S } = 2
this✝ : 2 ≤ 2
this : 0 < 2
⊢ S = ⊥ ∨ S = ⊤
[PROOFSTEP]
right
[GOAL]
case «2».h
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
hr : finrank F E = 2
i : Nontrivial E := nontrivial_of_finrank_pos (LT.lt.trans_eq zero_lt_two (Eq.symm hr))
S : Subalgebra F E
this✝² : FiniteDimensional F E
this✝¹ : FiniteDimensional F { x // x ∈ S }
h : finrank F { x // x ∈ S } = 2
this✝ : 2 ≤ 2
this : 0 < 2
⊢ S = ⊤
[PROOFSTEP]
rw [← hr] at h 
[GOAL]
case «2».h
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
hr : finrank F E = 2
i : Nontrivial E := nontrivial_of_finrank_pos (LT.lt.trans_eq zero_lt_two (Eq.symm hr))
S : Subalgebra F E
this✝² : FiniteDimensional F E
this✝¹ : FiniteDimensional F { x // x ∈ S }
h : finrank F { x // x ∈ S } = finrank F E
this✝ : 2 ≤ 2
this : 0 < 2
⊢ S = ⊤
[PROOFSTEP]
rw [← Algebra.toSubmodule_eq_top]
[GOAL]
case «2».h
K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : Field F
inst✝¹ : Ring E
inst✝ : Algebra F E
hr : finrank F E = 2
i : Nontrivial E := nontrivial_of_finrank_pos (LT.lt.trans_eq zero_lt_two (Eq.symm hr))
S : Subalgebra F E
this✝² : FiniteDimensional F E
this✝¹ : FiniteDimensional F { x // x ∈ S }
h : finrank F { x // x ∈ S } = finrank F E
this✝ : 2 ≤ 2
this : 0 < 2
⊢ ↑toSubmodule S = ⊤
[PROOFSTEP]
exact eq_top_of_finrank_eq h
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
⊢ ∃ k, k ≤ finrank K V ∧ LinearMap.ker (f ^ k) = LinearMap.ker (f ^ Nat.succ k)
[PROOFSTEP]
classical
by_contra h_contra
simp_rw [not_exists, not_and] at h_contra 
have h_le_ker_pow : ∀ n : ℕ, n ≤ (finrank K V).succ → n ≤ finrank K (LinearMap.ker (f ^ n)) :=
  by
  intro n hn
  induction' n with n ih
  · exact zero_le (finrank _ _)
  · have h_ker_lt_ker : LinearMap.ker (f ^ n) < LinearMap.ker (f ^ n.succ) :=
      by
      refine' lt_of_le_of_ne _ (h_contra n (Nat.le_of_succ_le_succ hn))
      rw [pow_succ]
      apply LinearMap.ker_le_ker_comp
    have h_finrank_lt_finrank : finrank K (LinearMap.ker (f ^ n)) < finrank K (LinearMap.ker (f ^ n.succ)) := by
      apply Submodule.finrank_lt_finrank_of_lt h_ker_lt_ker
    calc
      n.succ ≤ (finrank K ↑(LinearMap.ker (f ^ n))).succ := Nat.succ_le_succ (ih (Nat.le_of_succ_le hn))
      _ ≤ finrank K ↑(LinearMap.ker (f ^ n.succ)) := Nat.succ_le_of_lt h_finrank_lt_finrank
have h_any_n_lt : ∀ n, n ≤ (finrank K V).succ → n ≤ finrank K V := fun n hn =>
  (h_le_ker_pow n hn).trans (Submodule.finrank_le _)
show False
exact Nat.not_succ_le_self _ (h_any_n_lt (finrank K V).succ (finrank K V).succ.le_refl)
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
⊢ ∃ k, k ≤ finrank K V ∧ LinearMap.ker (f ^ k) = LinearMap.ker (f ^ Nat.succ k)
[PROOFSTEP]
by_contra h_contra
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
h_contra : ¬∃ k, k ≤ finrank K V ∧ LinearMap.ker (f ^ k) = LinearMap.ker (f ^ Nat.succ k)
⊢ False
[PROOFSTEP]
simp_rw [not_exists, not_and] at h_contra 
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
h_contra : ∀ (x : ℕ), x ≤ finrank K V → ¬LinearMap.ker (f ^ x) = LinearMap.ker (f ^ Nat.succ x)
⊢ False
[PROOFSTEP]
have h_le_ker_pow : ∀ n : ℕ, n ≤ (finrank K V).succ → n ≤ finrank K (LinearMap.ker (f ^ n)) :=
  by
  intro n hn
  induction' n with n ih
  · exact zero_le (finrank _ _)
  · have h_ker_lt_ker : LinearMap.ker (f ^ n) < LinearMap.ker (f ^ n.succ) :=
      by
      refine' lt_of_le_of_ne _ (h_contra n (Nat.le_of_succ_le_succ hn))
      rw [pow_succ]
      apply LinearMap.ker_le_ker_comp
    have h_finrank_lt_finrank : finrank K (LinearMap.ker (f ^ n)) < finrank K (LinearMap.ker (f ^ n.succ)) := by
      apply Submodule.finrank_lt_finrank_of_lt h_ker_lt_ker
    calc
      n.succ ≤ (finrank K ↑(LinearMap.ker (f ^ n))).succ := Nat.succ_le_succ (ih (Nat.le_of_succ_le hn))
      _ ≤ finrank K ↑(LinearMap.ker (f ^ n.succ)) := Nat.succ_le_of_lt h_finrank_lt_finrank
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
h_contra : ∀ (x : ℕ), x ≤ finrank K V → ¬LinearMap.ker (f ^ x) = LinearMap.ker (f ^ Nat.succ x)
⊢ ∀ (n : ℕ), n ≤ Nat.succ (finrank K V) → n ≤ finrank K { x // x ∈ LinearMap.ker (f ^ n) }
[PROOFSTEP]
intro n hn
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
h_contra : ∀ (x : ℕ), x ≤ finrank K V → ¬LinearMap.ker (f ^ x) = LinearMap.ker (f ^ Nat.succ x)
n : ℕ
hn : n ≤ Nat.succ (finrank K V)
⊢ n ≤ finrank K { x // x ∈ LinearMap.ker (f ^ n) }
[PROOFSTEP]
induction' n with n ih
[GOAL]
case zero
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
h_contra : ∀ (x : ℕ), x ≤ finrank K V → ¬LinearMap.ker (f ^ x) = LinearMap.ker (f ^ Nat.succ x)
n : ℕ
hn✝ : n ≤ Nat.succ (finrank K V)
hn : Nat.zero ≤ Nat.succ (finrank K V)
⊢ Nat.zero ≤ finrank K { x // x ∈ LinearMap.ker (f ^ Nat.zero) }
[PROOFSTEP]
exact zero_le (finrank _ _)
[GOAL]
case succ
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
h_contra : ∀ (x : ℕ), x ≤ finrank K V → ¬LinearMap.ker (f ^ x) = LinearMap.ker (f ^ Nat.succ x)
n✝ : ℕ
hn✝ : n✝ ≤ Nat.succ (finrank K V)
n : ℕ
ih : n ≤ Nat.succ (finrank K V) → n ≤ finrank K { x // x ∈ LinearMap.ker (f ^ n) }
hn : Nat.succ n ≤ Nat.succ (finrank K V)
⊢ Nat.succ n ≤ finrank K { x // x ∈ LinearMap.ker (f ^ Nat.succ n) }
[PROOFSTEP]
have h_ker_lt_ker : LinearMap.ker (f ^ n) < LinearMap.ker (f ^ n.succ) :=
  by
  refine' lt_of_le_of_ne _ (h_contra n (Nat.le_of_succ_le_succ hn))
  rw [pow_succ]
  apply LinearMap.ker_le_ker_comp
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
h_contra : ∀ (x : ℕ), x ≤ finrank K V → ¬LinearMap.ker (f ^ x) = LinearMap.ker (f ^ Nat.succ x)
n✝ : ℕ
hn✝ : n✝ ≤ Nat.succ (finrank K V)
n : ℕ
ih : n ≤ Nat.succ (finrank K V) → n ≤ finrank K { x // x ∈ LinearMap.ker (f ^ n) }
hn : Nat.succ n ≤ Nat.succ (finrank K V)
⊢ LinearMap.ker (f ^ n) < LinearMap.ker (f ^ Nat.succ n)
[PROOFSTEP]
refine' lt_of_le_of_ne _ (h_contra n (Nat.le_of_succ_le_succ hn))
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
h_contra : ∀ (x : ℕ), x ≤ finrank K V → ¬LinearMap.ker (f ^ x) = LinearMap.ker (f ^ Nat.succ x)
n✝ : ℕ
hn✝ : n✝ ≤ Nat.succ (finrank K V)
n : ℕ
ih : n ≤ Nat.succ (finrank K V) → n ≤ finrank K { x // x ∈ LinearMap.ker (f ^ n) }
hn : Nat.succ n ≤ Nat.succ (finrank K V)
⊢ LinearMap.ker (f ^ n) ≤ LinearMap.ker (f ^ Nat.succ n)
[PROOFSTEP]
rw [pow_succ]
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
h_contra : ∀ (x : ℕ), x ≤ finrank K V → ¬LinearMap.ker (f ^ x) = LinearMap.ker (f ^ Nat.succ x)
n✝ : ℕ
hn✝ : n✝ ≤ Nat.succ (finrank K V)
n : ℕ
ih : n ≤ Nat.succ (finrank K V) → n ≤ finrank K { x // x ∈ LinearMap.ker (f ^ n) }
hn : Nat.succ n ≤ Nat.succ (finrank K V)
⊢ LinearMap.ker (f ^ n) ≤ LinearMap.ker (f * f ^ n)
[PROOFSTEP]
apply LinearMap.ker_le_ker_comp
[GOAL]
case succ
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
h_contra : ∀ (x : ℕ), x ≤ finrank K V → ¬LinearMap.ker (f ^ x) = LinearMap.ker (f ^ Nat.succ x)
n✝ : ℕ
hn✝ : n✝ ≤ Nat.succ (finrank K V)
n : ℕ
ih : n ≤ Nat.succ (finrank K V) → n ≤ finrank K { x // x ∈ LinearMap.ker (f ^ n) }
hn : Nat.succ n ≤ Nat.succ (finrank K V)
h_ker_lt_ker : LinearMap.ker (f ^ n) < LinearMap.ker (f ^ Nat.succ n)
⊢ Nat.succ n ≤ finrank K { x // x ∈ LinearMap.ker (f ^ Nat.succ n) }
[PROOFSTEP]
have h_finrank_lt_finrank : finrank K (LinearMap.ker (f ^ n)) < finrank K (LinearMap.ker (f ^ n.succ)) := by
  apply Submodule.finrank_lt_finrank_of_lt h_ker_lt_ker
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
h_contra : ∀ (x : ℕ), x ≤ finrank K V → ¬LinearMap.ker (f ^ x) = LinearMap.ker (f ^ Nat.succ x)
n✝ : ℕ
hn✝ : n✝ ≤ Nat.succ (finrank K V)
n : ℕ
ih : n ≤ Nat.succ (finrank K V) → n ≤ finrank K { x // x ∈ LinearMap.ker (f ^ n) }
hn : Nat.succ n ≤ Nat.succ (finrank K V)
h_ker_lt_ker : LinearMap.ker (f ^ n) < LinearMap.ker (f ^ Nat.succ n)
⊢ finrank K { x // x ∈ LinearMap.ker (f ^ n) } < finrank K { x // x ∈ LinearMap.ker (f ^ Nat.succ n) }
[PROOFSTEP]
apply Submodule.finrank_lt_finrank_of_lt h_ker_lt_ker
[GOAL]
case succ
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
h_contra : ∀ (x : ℕ), x ≤ finrank K V → ¬LinearMap.ker (f ^ x) = LinearMap.ker (f ^ Nat.succ x)
n✝ : ℕ
hn✝ : n✝ ≤ Nat.succ (finrank K V)
n : ℕ
ih : n ≤ Nat.succ (finrank K V) → n ≤ finrank K { x // x ∈ LinearMap.ker (f ^ n) }
hn : Nat.succ n ≤ Nat.succ (finrank K V)
h_ker_lt_ker : LinearMap.ker (f ^ n) < LinearMap.ker (f ^ Nat.succ n)
h_finrank_lt_finrank :
  finrank K { x // x ∈ LinearMap.ker (f ^ n) } < finrank K { x // x ∈ LinearMap.ker (f ^ Nat.succ n) }
⊢ Nat.succ n ≤ finrank K { x // x ∈ LinearMap.ker (f ^ Nat.succ n) }
[PROOFSTEP]
calc
  n.succ ≤ (finrank K ↑(LinearMap.ker (f ^ n))).succ := Nat.succ_le_succ (ih (Nat.le_of_succ_le hn))
  _ ≤ finrank K ↑(LinearMap.ker (f ^ n.succ)) := Nat.succ_le_of_lt h_finrank_lt_finrank
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
h_contra : ∀ (x : ℕ), x ≤ finrank K V → ¬LinearMap.ker (f ^ x) = LinearMap.ker (f ^ Nat.succ x)
h_le_ker_pow : ∀ (n : ℕ), n ≤ Nat.succ (finrank K V) → n ≤ finrank K { x // x ∈ LinearMap.ker (f ^ n) }
⊢ False
[PROOFSTEP]
have h_any_n_lt : ∀ n, n ≤ (finrank K V).succ → n ≤ finrank K V := fun n hn =>
  (h_le_ker_pow n hn).trans (Submodule.finrank_le _)
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
h_contra : ∀ (x : ℕ), x ≤ finrank K V → ¬LinearMap.ker (f ^ x) = LinearMap.ker (f ^ Nat.succ x)
h_le_ker_pow : ∀ (n : ℕ), n ≤ Nat.succ (finrank K V) → n ≤ finrank K { x // x ∈ LinearMap.ker (f ^ n) }
h_any_n_lt : ∀ (n : ℕ), n ≤ Nat.succ (finrank K V) → n ≤ finrank K V
⊢ False
[PROOFSTEP]
show False
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
h_contra : ∀ (x : ℕ), x ≤ finrank K V → ¬LinearMap.ker (f ^ x) = LinearMap.ker (f ^ Nat.succ x)
h_le_ker_pow : ∀ (n : ℕ), n ≤ Nat.succ (finrank K V) → n ≤ finrank K { x // x ∈ LinearMap.ker (f ^ n) }
h_any_n_lt : ∀ (n : ℕ), n ≤ Nat.succ (finrank K V) → n ≤ finrank K V
⊢ False
[PROOFSTEP]
exact Nat.not_succ_le_self _ (h_any_n_lt (finrank K V).succ (finrank K V).succ.le_refl)
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
k : ℕ
h : LinearMap.ker (f ^ k) = LinearMap.ker (f ^ Nat.succ k)
⊢ LinearMap.ker (f ^ k) = LinearMap.ker (f ^ (k + 0))
[PROOFSTEP]
simp
[GOAL]
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
k : ℕ
h : LinearMap.ker (f ^ k) = LinearMap.ker (f ^ Nat.succ k)
m : ℕ
⊢ LinearMap.ker (f ^ k) = LinearMap.ker (f ^ (k + (m + 1)))
[PROOFSTEP]
apply le_antisymm
[GOAL]
case a
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
k : ℕ
h : LinearMap.ker (f ^ k) = LinearMap.ker (f ^ Nat.succ k)
m : ℕ
⊢ LinearMap.ker (f ^ k) ≤ LinearMap.ker (f ^ (k + (m + 1)))
[PROOFSTEP]
rw [add_comm, pow_add]
[GOAL]
case a
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
k : ℕ
h : LinearMap.ker (f ^ k) = LinearMap.ker (f ^ Nat.succ k)
m : ℕ
⊢ LinearMap.ker (f ^ k) ≤ LinearMap.ker (f ^ (m + 1) * f ^ k)
[PROOFSTEP]
apply LinearMap.ker_le_ker_comp
[GOAL]
case a
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
k : ℕ
h : LinearMap.ker (f ^ k) = LinearMap.ker (f ^ Nat.succ k)
m : ℕ
⊢ LinearMap.ker (f ^ (k + (m + 1))) ≤ LinearMap.ker (f ^ k)
[PROOFSTEP]
rw [ker_pow_constant h m, add_comm m 1, ← add_assoc, pow_add, pow_add f k m, LinearMap.mul_eq_comp,
  LinearMap.mul_eq_comp, LinearMap.ker_comp, LinearMap.ker_comp, h, Nat.add_one]
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
m : ℕ
hm : finrank K V ≤ m
⊢ LinearMap.ker (f ^ m) = LinearMap.ker (f ^ finrank K V)
[PROOFSTEP]
obtain ⟨k, h_k_le, hk⟩ : ∃ k, k ≤ finrank K V ∧ LinearMap.ker (f ^ k) = LinearMap.ker (f ^ k.succ) :=
  exists_ker_pow_eq_ker_pow_succ f
[GOAL]
case intro.intro
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
m : ℕ
hm : finrank K V ≤ m
k : ℕ
h_k_le : k ≤ finrank K V
hk : LinearMap.ker (f ^ k) = LinearMap.ker (f ^ Nat.succ k)
⊢ LinearMap.ker (f ^ m) = LinearMap.ker (f ^ finrank K V)
[PROOFSTEP]
calc
  LinearMap.ker (f ^ m) = LinearMap.ker (f ^ (k + (m - k))) := by rw [add_tsub_cancel_of_le (h_k_le.trans hm)]
  _ = LinearMap.ker (f ^ k) := by rw [ker_pow_constant hk _]
  _ = LinearMap.ker (f ^ (k + (finrank K V - k))) := (ker_pow_constant hk (finrank K V - k))
  _ = LinearMap.ker (f ^ finrank K V) := by rw [add_tsub_cancel_of_le h_k_le]
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
m : ℕ
hm : finrank K V ≤ m
k : ℕ
h_k_le : k ≤ finrank K V
hk : LinearMap.ker (f ^ k) = LinearMap.ker (f ^ Nat.succ k)
⊢ LinearMap.ker (f ^ m) = LinearMap.ker (f ^ (k + (m - k)))
[PROOFSTEP]
rw [add_tsub_cancel_of_le (h_k_le.trans hm)]
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
m : ℕ
hm : finrank K V ≤ m
k : ℕ
h_k_le : k ≤ finrank K V
hk : LinearMap.ker (f ^ k) = LinearMap.ker (f ^ Nat.succ k)
⊢ LinearMap.ker (f ^ (k + (m - k))) = LinearMap.ker (f ^ k)
[PROOFSTEP]
rw [ker_pow_constant hk _]
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
m : ℕ
hm : finrank K V ≤ m
k : ℕ
h_k_le : k ≤ finrank K V
hk : LinearMap.ker (f ^ k) = LinearMap.ker (f ^ Nat.succ k)
⊢ LinearMap.ker (f ^ (k + (finrank K V - k))) = LinearMap.ker (f ^ finrank K V)
[PROOFSTEP]
rw [add_tsub_cancel_of_le h_k_le]
[GOAL]
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
m : ℕ
⊢ LinearMap.ker (f ^ m) ≤ LinearMap.ker (f ^ finrank K V)
[PROOFSTEP]
by_cases h_cases : m < finrank K V
[GOAL]
case pos
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
m : ℕ
h_cases : m < finrank K V
⊢ LinearMap.ker (f ^ m) ≤ LinearMap.ker (f ^ finrank K V)
[PROOFSTEP]
rw [← add_tsub_cancel_of_le (Nat.le_of_lt h_cases), add_comm, pow_add]
[GOAL]
case pos
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
m : ℕ
h_cases : m < finrank K V
⊢ LinearMap.ker (f ^ m) ≤ LinearMap.ker (f ^ (finrank K V - m) * f ^ m)
[PROOFSTEP]
apply LinearMap.ker_le_ker_comp
[GOAL]
case neg
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
m : ℕ
h_cases : ¬m < finrank K V
⊢ LinearMap.ker (f ^ m) ≤ LinearMap.ker (f ^ finrank K V)
[PROOFSTEP]
rw [ker_pow_eq_ker_pow_finrank_of_le (le_of_not_lt h_cases)]
[GOAL]
K✝ : Type u
V✝ : Type v
K V : Type u
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
⊢ #V = #K ^ Module.rank K V
[PROOFSTEP]
let s := Basis.ofVectorSpaceIndex K V
[GOAL]
K✝ : Type u
V✝ : Type v
K V : Type u
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s : Set V := Basis.ofVectorSpaceIndex K V
⊢ #V = #K ^ Module.rank K V
[PROOFSTEP]
let hs := Basis.ofVectorSpace K V
[GOAL]
K✝ : Type u
V✝ : Type v
K V : Type u
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s : Set V := Basis.ofVectorSpaceIndex K V
hs : Basis (↑(Basis.ofVectorSpaceIndex K V)) K V := Basis.ofVectorSpace K V
⊢ #V = #K ^ Module.rank K V
[PROOFSTEP]
calc
  #V = #(s →₀ K) := Quotient.sound ⟨hs.repr.toEquiv⟩
  _ = #(s → K) := (Quotient.sound ⟨Finsupp.equivFunOnFinite⟩)
  _ = _ := by rw [← Cardinal.lift_inj.1 hs.mk_eq_rank, Cardinal.power_def]
[GOAL]
K✝ : Type u
V✝ : Type v
K V : Type u
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s : Set V := Basis.ofVectorSpaceIndex K V
hs : Basis (↑(Basis.ofVectorSpaceIndex K V)) K V := Basis.ofVectorSpace K V
⊢ #(↑s → K) = #K ^ Module.rank K V
[PROOFSTEP]
rw [← Cardinal.lift_inj.1 hs.mk_eq_rank, Cardinal.power_def]
[GOAL]
K✝ : Type u
V✝ : Type v
K V : Type u
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
inst✝¹ : _root_.Finite K
inst✝ : FiniteDimensional K V
⊢ #V < ℵ₀
[PROOFSTEP]
letI : IsNoetherian K V := IsNoetherian.iff_fg.2 inferInstance
[GOAL]
K✝ : Type u
V✝ : Type v
K V : Type u
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
inst✝¹ : _root_.Finite K
inst✝ : FiniteDimensional K V
this : IsNoetherian K V := Iff.mpr IsNoetherian.iff_fg inferInstance
⊢ #V < ℵ₀
[PROOFSTEP]
rw [cardinal_mk_eq_cardinal_mk_field_pow_rank K V]
[GOAL]
K✝ : Type u
V✝ : Type v
K V : Type u
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
inst✝¹ : _root_.Finite K
inst✝ : FiniteDimensional K V
this : IsNoetherian K V := Iff.mpr IsNoetherian.iff_fg inferInstance
⊢ #K ^ Module.rank K V < ℵ₀
[PROOFSTEP]
exact Cardinal.power_lt_aleph0 (Cardinal.lt_aleph0_of_finite K) (IsNoetherian.rank_lt_aleph0 K V)
