l3lab/ntp-mathlib huggingface dataset:
/-- The rank of a finite product of free modules is the sum of the ranks. -/
-- this result is not true without the freeness assumption
@[simp]
theorem rank_pi [Finite η] : Module.rank K (∀ i, φ i) =
    Cardinal.sum fun i => Module.rank K (φ i) := by
  

Proof state:
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁴ : Ring K
inst✝¹³ : StrongRankCondition K
inst✝¹² : AddCommGroup V
inst✝¹¹ : Module K V
inst✝¹⁰ : Module.Free K V
inst✝⁹ : AddCommGroup V'
inst✝⁸ : Module K V'
inst✝⁷ : Module.Free K V'
inst✝⁶ : AddCommGroup V₁
inst✝⁵ : Module K V₁
inst✝⁴ : Module.Free K V₁
inst✝³ : (i : η) → AddCommGroup (φ i)
inst✝² : (i : η) → Module K (φ i)
inst✝¹ : ∀ (i : η), Module.Free K (φ i)
inst✝ : Finite η
⊢ Module.rank K ((i : η) → φ i) = sum fun i => Module.rank K (φ i)

Next tactic:
cases nonempty_fintype η
/-- The rank of a finite product of free modules is the sum of the ranks. -/
-- this result is not true without the freeness assumption
@[simp]
theorem rank_pi [Finite η] : Module.rank K (∀ i, φ i) =
    Cardinal.sum fun i => Module.rank K (φ i) := by
  cases nonempty_fintype η
  

Proof state:
case intro
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁴ : Ring K
inst✝¹³ : StrongRankCondition K
inst✝¹² : AddCommGroup V
inst✝¹¹ : Module K V
inst✝¹⁰ : Module.Free K V
inst✝⁹ : AddCommGroup V'
inst✝⁸ : Module K V'
inst✝⁷ : Module.Free K V'
inst✝⁶ : AddCommGroup V₁
inst✝⁵ : Module K V₁
inst✝⁴ : Module.Free K V₁
inst✝³ : (i : η) → AddCommGroup (φ i)
inst✝² : (i : η) → Module K (φ i)
inst✝¹ : ∀ (i : η), Module.Free K (φ i)
inst✝ : Finite η
val✝ : Fintype η
⊢ Module.rank K ((i : η) → φ i) = sum fun i => Module.rank K (φ i)

Next tactic:
let B i := chooseBasis K (φ i)
/-- The rank of a finite product of free modules is the sum of the ranks. -/
-- this result is not true without the freeness assumption
@[simp]
theorem rank_pi [Finite η] : Module.rank K (∀ i, φ i) =
    Cardinal.sum fun i => Module.rank K (φ i) := by
  cases nonempty_fintype η
  let B i := chooseBasis K (φ i)
  

Proof state:
case intro
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁴ : Ring K
inst✝¹³ : StrongRankCondition K
inst✝¹² : AddCommGroup V
inst✝¹¹ : Module K V
inst✝¹⁰ : Module.Free K V
inst✝⁹ : AddCommGroup V'
inst✝⁸ : Module K V'
inst✝⁷ : Module.Free K V'
inst✝⁶ : AddCommGroup V₁
inst✝⁵ : Module K V₁
inst✝⁴ : Module.Free K V₁
inst✝³ : (i : η) → AddCommGroup (φ i)
inst✝² : (i : η) → Module K (φ i)
inst✝¹ : ∀ (i : η), Module.Free K (φ i)
inst✝ : Finite η
val✝ : Fintype η
B : (i : η) → Basis (ChooseBasisIndex K (φ i)) K (φ i) := fun i => chooseBasis K (φ i)
⊢ Module.rank K ((i : η) → φ i) = sum fun i => Module.rank K (φ i)

Next tactic:
let b : Basis _ K (∀ i, φ i) := Pi.basis fun i => B i
/-- The rank of a finite product of free modules is the sum of the ranks. -/
-- this result is not true without the freeness assumption
@[simp]
theorem rank_pi [Finite η] : Module.rank K (∀ i, φ i) =
    Cardinal.sum fun i => Module.rank K (φ i) := by
  cases nonempty_fintype η
  let B i := chooseBasis K (φ i)
  let b : Basis _ K (∀ i, φ i) := Pi.basis fun i => B i
  

Proof state:
case intro
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁴ : Ring K
inst✝¹³ : StrongRankCondition K
inst✝¹² : AddCommGroup V
inst✝¹¹ : Module K V
inst✝¹⁰ : Module.Free K V
inst✝⁹ : AddCommGroup V'
inst✝⁸ : Module K V'
inst✝⁷ : Module.Free K V'
inst✝⁶ : AddCommGroup V₁
inst✝⁵ : Module K V₁
inst✝⁴ : Module.Free K V₁
inst✝³ : (i : η) → AddCommGroup (φ i)
inst✝² : (i : η) → Module K (φ i)
inst✝¹ : ∀ (i : η), Module.Free K (φ i)
inst✝ : Finite η
val✝ : Fintype η
B : (i : η) → Basis (ChooseBasisIndex K (φ i)) K (φ i) := fun i => chooseBasis K (φ i)
b : Basis ((j : η) × ChooseBasisIndex K (φ j)) K ((i : η) → φ i) := Pi.basis fun i => B i
⊢ Module.rank K ((i : η) → φ i) = sum fun i => Module.rank K (φ i)

Next tactic:
simp [← b.mk_eq_rank'', fun i => (B i).mk_eq_rank'']
theorem rank_fun {V η : Type u} [Fintype η] [AddCommGroup V] [Module K V] [Module.Free K V] :
    Module.rank K (η → V) = Fintype.card η * Module.rank K V := by
  

Proof state:
K R : Type u
V✝ V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η✝ : Type u₁'
φ : η✝ → Type u_1
inst✝¹⁸ : Ring K
inst✝¹⁷ : StrongRankCondition K
inst✝¹⁶ : AddCommGroup V✝
inst✝¹⁵ : Module K V✝
inst✝¹⁴ : Module.Free K V✝
inst✝¹³ : AddCommGroup V'
inst✝¹² : Module K V'
inst✝¹¹ : Module.Free K V'
inst✝¹⁰ : AddCommGroup V₁
inst✝⁹ : Module K V₁
inst✝⁸ : Module.Free K V₁
inst✝⁷ : (i : η✝) → AddCommGroup (φ i)
inst✝⁶ : (i : η✝) → Module K (φ i)
inst✝⁵ : ∀ (i : η✝), Module.Free K (φ i)
inst✝⁴ : Fintype η✝
V η : Type u
inst✝³ : Fintype η
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Module.Free K V
⊢ Module.rank K (η → V) = ↑(Fintype.card η) * Module.rank K V

Next tactic:
rw [rank_pi, Cardinal.sum_const', Cardinal.mk_fintype]
theorem rank_fun_eq_lift_mul : Module.rank K (η → V) =
    (Fintype.card η : Cardinal.{max u₁' v}) * Cardinal.lift.{u₁'} (Module.rank K V) :=
  by 

Proof state:
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁴ : Ring K
inst✝¹³ : StrongRankCondition K
inst✝¹² : AddCommGroup V
inst✝¹¹ : Module K V
inst✝¹⁰ : Module.Free K V
inst✝⁹ : AddCommGroup V'
inst✝⁸ : Module K V'
inst✝⁷ : Module.Free K V'
inst✝⁶ : AddCommGroup V₁
inst✝⁵ : Module K V₁
inst✝⁴ : Module.Free K V₁
inst✝³ : (i : η) → AddCommGroup (φ i)
inst✝² : (i : η) → Module K (φ i)
inst✝¹ : ∀ (i : η), Module.Free K (φ i)
inst✝ : Fintype η
⊢ Module.rank K (η → V) = ↑(Fintype.card η) * lift.{u₁', v} (Module.rank K V)

Next tactic:
rw [rank_pi, Cardinal.sum_const, Cardinal.mk_fintype, Cardinal.lift_natCast]
theorem rank_fun' : Module.rank K (η → K) = Fintype.card η := by
  

Proof state:
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁴ : Ring K
inst✝¹³ : StrongRankCondition K
inst✝¹² : AddCommGroup V
inst✝¹¹ : Module K V
inst✝¹⁰ : Module.Free K V
inst✝⁹ : AddCommGroup V'
inst✝⁸ : Module K V'
inst✝⁷ : Module.Free K V'
inst✝⁶ : AddCommGroup V₁
inst✝⁵ : Module K V₁
inst✝⁴ : Module.Free K V₁
inst✝³ : (i : η) → AddCommGroup (φ i)
inst✝² : (i : η) → Module K (φ i)
inst✝¹ : ∀ (i : η), Module.Free K (φ i)
inst✝ : Fintype η
⊢ Module.rank K (η → K) = ↑(Fintype.card η)

Next tactic:
rw [rank_fun_eq_lift_mul, rank_self, Cardinal.lift_one, mul_one, Cardinal.natCast_inj]
theorem rank_fin_fun (n : ℕ) : Module.rank K (Fin n → K) = n := by 

Proof state:
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁴ : Ring K
inst✝¹³ : StrongRankCondition K
inst✝¹² : AddCommGroup V
inst✝¹¹ : Module K V
inst✝¹⁰ : Module.Free K V
inst✝⁹ : AddCommGroup V'
inst✝⁸ : Module K V'
inst✝⁷ : Module.Free K V'
inst✝⁶ : AddCommGroup V₁
inst✝⁵ : Module K V₁
inst✝⁴ : Module.Free K V₁
inst✝³ : (i : η) → AddCommGroup (φ i)
inst✝² : (i : η) → Module K (φ i)
inst✝¹ : ∀ (i : η), Module.Free K (φ i)
inst✝ : Fintype η
n : ℕ
⊢ Module.rank K (Fin n → K) = ↑n

Next tactic:
simp [rank_fun']
/-- An `n`-dimensional `K`-vector space is equivalent to `Fin n → K`. -/
def finDimVectorspaceEquiv (n : ℕ) (hn : Module.rank K V = n) : V ≃ₗ[K] Fin n → K := by
  

Proof state:
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁰ : Ring K
inst✝⁹ : StrongRankCondition K
inst✝⁸ : AddCommGroup V
inst✝⁷ : Module K V
inst✝⁶ : Module.Free K V
inst✝⁵ : AddCommGroup V'
inst✝⁴ : Module K V'
inst✝³ : Module.Free K V'
inst✝² : AddCommGroup V₁
inst✝¹ : Module K V₁
inst✝ : Module.Free K V₁
n : ℕ
hn : Module.rank K V = ↑n
⊢ V ≃ₗ[K] Fin n → K

Next tactic:
haveI := nontrivial_of_invariantBasisNumber K
/-- An `n`-dimensional `K`-vector space is equivalent to `Fin n → K`. -/
def finDimVectorspaceEquiv (n : ℕ) (hn : Module.rank K V = n) : V ≃ₗ[K] Fin n → K := by
  haveI := nontrivial_of_invariantBasisNumber K
  

Proof state:
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁰ : Ring K
inst✝⁹ : StrongRankCondition K
inst✝⁸ : AddCommGroup V
inst✝⁷ : Module K V
inst✝⁶ : Module.Free K V
inst✝⁵ : AddCommGroup V'
inst✝⁴ : Module K V'
inst✝³ : Module.Free K V'
inst✝² : AddCommGroup V₁
inst✝¹ : Module K V₁
inst✝ : Module.Free K V₁
n : ℕ
hn : Module.rank K V = ↑n
this : Nontrivial K
⊢ V ≃ₗ[K] Fin n → K

Next tactic:
have : Cardinal.lift.{u} (n : Cardinal.{v}) = Cardinal.lift.{v} (n : Cardinal.{u}) := by simp
/-- An `n`-dimensional `K`-vector space is equivalent to `Fin n → K`. -/
def finDimVectorspaceEquiv (n : ℕ) (hn : Module.rank K V = n) : V ≃ₗ[K] Fin n → K := by
  haveI := nontrivial_of_invariantBasisNumber K
  have : Cardinal.lift.{u} (n : Cardinal.{v}) = Cardinal.lift.{v} (n : Cardinal.{u}) := by 

Proof state:
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁰ : Ring K
inst✝⁹ : StrongRankCondition K
inst✝⁸ : AddCommGroup V
inst✝⁷ : Module K V
inst✝⁶ : Module.Free K V
inst✝⁵ : AddCommGroup V'
inst✝⁴ : Module K V'
inst✝³ : Module.Free K V'
inst✝² : AddCommGroup V₁
inst✝¹ : Module K V₁
inst✝ : Module.Free K V₁
n : ℕ
hn : Module.rank K V = ↑n
this : Nontrivial K
⊢ lift.{u, v} ↑n = lift.{v, u} ↑n

Next tactic:
simp
/-- An `n`-dimensional `K`-vector space is equivalent to `Fin n → K`. -/
def finDimVectorspaceEquiv (n : ℕ) (hn : Module.rank K V = n) : V ≃ₗ[K] Fin n → K := by
  haveI := nontrivial_of_invariantBasisNumber K
  have : Cardinal.lift.{u} (n : Cardinal.{v}) = Cardinal.lift.{v} (n : Cardinal.{u}) := by simp
  

Proof state:
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁰ : Ring K
inst✝⁹ : StrongRankCondition K
inst✝⁸ : AddCommGroup V
inst✝⁷ : Module K V
inst✝⁶ : Module.Free K V
inst✝⁵ : AddCommGroup V'
inst✝⁴ : Module K V'
inst✝³ : Module.Free K V'
inst✝² : AddCommGroup V₁
inst✝¹ : Module K V₁
inst✝ : Module.Free K V₁
n : ℕ
hn : Module.rank K V = ↑n
this✝ : Nontrivial K
this : lift.{u, v} ↑n = lift.{v, u} ↑n
⊢ V ≃ₗ[K] Fin n → K

Next tactic:
have hn := Cardinal.lift_inj.{v, u}.2 hn
/-- An `n`-dimensional `K`-vector space is equivalent to `Fin n → K`. -/
def finDimVectorspaceEquiv (n : ℕ) (hn : Module.rank K V = n) : V ≃ₗ[K] Fin n → K := by
  haveI := nontrivial_of_invariantBasisNumber K
  have : Cardinal.lift.{u} (n : Cardinal.{v}) = Cardinal.lift.{v} (n : Cardinal.{u}) := by simp
  have hn := Cardinal.lift_inj.{v, u}.2 hn
  

Proof state:
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁰ : Ring K
inst✝⁹ : StrongRankCondition K
inst✝⁸ : AddCommGroup V
inst✝⁷ : Module K V
inst✝⁶ : Module.Free K V
inst✝⁵ : AddCommGroup V'
inst✝⁴ : Module K V'
inst✝³ : Module.Free K V'
inst✝² : AddCommGroup V₁
inst✝¹ : Module K V₁
inst✝ : Module.Free K V₁
n : ℕ
hn✝ : Module.rank K V = ↑n
this✝ : Nontrivial K
this : lift.{u, v} ↑n = lift.{v, u} ↑n
hn : lift.{u, v} (Module.rank K V) = lift.{u, v} ↑n
⊢ V ≃ₗ[K] Fin n → K

Next tactic:
rw [this] at hn
/-- An `n`-dimensional `K`-vector space is equivalent to `Fin n → K`. -/
def finDimVectorspaceEquiv (n : ℕ) (hn : Module.rank K V = n) : V ≃ₗ[K] Fin n → K := by
  haveI := nontrivial_of_invariantBasisNumber K
  have : Cardinal.lift.{u} (n : Cardinal.{v}) = Cardinal.lift.{v} (n : Cardinal.{u}) := by simp
  have hn := Cardinal.lift_inj.{v, u}.2 hn
  rw [this] at hn
  

Proof state:
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁰ : Ring K
inst✝⁹ : StrongRankCondition K
inst✝⁸ : AddCommGroup V
inst✝⁷ : Module K V
inst✝⁶ : Module.Free K V
inst✝⁵ : AddCommGroup V'
inst✝⁴ : Module K V'
inst✝³ : Module.Free K V'
inst✝² : AddCommGroup V₁
inst✝¹ : Module K V₁
inst✝ : Module.Free K V₁
n : ℕ
hn✝ : Module.rank K V = ↑n
this✝ : Nontrivial K
this : lift.{u, v} ↑n = lift.{v, u} ↑n
hn : lift.{u, v} (Module.rank K V) = lift.{v, u} ↑n
⊢ V ≃ₗ[K] Fin n → K

Next tactic:
rw [← @rank_fin_fun K _ _ n] at hn
/-- An `n`-dimensional `K`-vector space is equivalent to `Fin n → K`. -/
def finDimVectorspaceEquiv (n : ℕ) (hn : Module.rank K V = n) : V ≃ₗ[K] Fin n → K := by
  haveI := nontrivial_of_invariantBasisNumber K
  have : Cardinal.lift.{u} (n : Cardinal.{v}) = Cardinal.lift.{v} (n : Cardinal.{u}) := by simp
  have hn := Cardinal.lift_inj.{v, u}.2 hn
  rw [this] at hn
  rw [← @rank_fin_fun K _ _ n] at hn
  

Proof state:
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁰ : Ring K
inst✝⁹ : StrongRankCondition K
inst✝⁸ : AddCommGroup V
inst✝⁷ : Module K V
inst✝⁶ : Module.Free K V
inst✝⁵ : AddCommGroup V'
inst✝⁴ : Module K V'
inst✝³ : Module.Free K V'
inst✝² : AddCommGroup V₁
inst✝¹ : Module K V₁
inst✝ : Module.Free K V₁
n : ℕ
hn✝ : Module.rank K V = ↑n
this✝ : Nontrivial K
this : lift.{u, v} ↑n = lift.{v, u} ↑n
hn : lift.{u, v} (Module.rank K V) = lift.{v, u} (Module.rank K (Fin n → K))
⊢ V ≃ₗ[K] Fin n → K

Next tactic:
haveI : Module.Free K (Fin n → K) := Module.Free.pi _ _
/-- An `n`-dimensional `K`-vector space is equivalent to `Fin n → K`. -/
def finDimVectorspaceEquiv (n : ℕ) (hn : Module.rank K V = n) : V ≃ₗ[K] Fin n → K := by
  haveI := nontrivial_of_invariantBasisNumber K
  have : Cardinal.lift.{u} (n : Cardinal.{v}) = Cardinal.lift.{v} (n : Cardinal.{u}) := by simp
  have hn := Cardinal.lift_inj.{v, u}.2 hn
  rw [this] at hn
  rw [← @rank_fin_fun K _ _ n] at hn
  haveI : Module.Free K (Fin n → K) := Module.Free.pi _ _
  

Proof state:
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁰ : Ring K
inst✝⁹ : StrongRankCondition K
inst✝⁸ : AddCommGroup V
inst✝⁷ : Module K V
inst✝⁶ : Module.Free K V
inst✝⁵ : AddCommGroup V'
inst✝⁴ : Module K V'
inst✝³ : Module.Free K V'
inst✝² : AddCommGroup V₁
inst✝¹ : Module K V₁
inst✝ : Module.Free K V₁
n : ℕ
hn✝ : Module.rank K V = ↑n
this✝¹ : Nontrivial K
this✝ : lift.{u, v} ↑n = lift.{v, u} ↑n
hn : lift.{u, v} (Module.rank K V) = lift.{v, u} (Module.rank K (Fin n → K))
this : Module.Free K (Fin n → K)
⊢ V ≃ₗ[K] Fin n → K

Next tactic:
exact Classical.choice (nonempty_linearEquiv_of_lift_rank_eq hn)
theorem rank_span_le (s : Set V) : Module.rank K (span K s) ≤ #s := by
  

Proof state:
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁹ : DivisionRing K
inst✝⁸ : Ring R
inst✝⁷ : StrongRankCondition R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module K V
inst✝⁴ : Module R V
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V₁
inst✝ : Module K V₁
s : Set V
⊢ Module.rank K ↥(span K s) ≤ #↑s

Next tactic:
obtain ⟨b, hb, hsab, hlib⟩ := exists_linearIndependent K s
theorem rank_span_le (s : Set V) : Module.rank K (span K s) ≤ #s := by
  obtain ⟨b, hb, hsab, hlib⟩ := exists_linearIndependent K s
  

Proof state:
case intro.intro.intro
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁹ : DivisionRing K
inst✝⁸ : Ring R
inst✝⁷ : StrongRankCondition R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module K V
inst✝⁴ : Module R V
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V₁
inst✝ : Module K V₁
s b : Set V
hb : b ⊆ s
hsab : span K b = span K s
hlib : LinearIndependent (ι := { x // x ∈ b }) K Subtype.val
⊢ Module.rank K ↥(span K s) ≤ #↑s

Next tactic:
convert Cardinal.mk_le_mk_of_subset hb
theorem rank_span_le (s : Set V) : Module.rank K (span K s) ≤ #s := by
  obtain ⟨b, hb, hsab, hlib⟩ := exists_linearIndependent K s
  convert Cardinal.mk_le_mk_of_subset hb
  

Proof state:
case h.e'_3
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁹ : DivisionRing K
inst✝⁸ : Ring R
inst✝⁷ : StrongRankCondition R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module K V
inst✝⁴ : Module R V
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V₁
inst✝ : Module K V₁
s b : Set V
hb : b ⊆ s
hsab : span K b = span K s
hlib : LinearIndependent (ι := { x // x ∈ b }) K Subtype.val
⊢ Module.rank K ↥(span K s) = #↑b

Next tactic:
rw [← hsab, rank_span_set hlib]
theorem rank_span_le_of_finite {s : Set V} (hs : s.Finite) : Module.rank R (span R s) ≤ #s := by
  

Proof state:
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁹ : DivisionRing K
inst✝⁸ : Ring R
inst✝⁷ : StrongRankCondition R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module K V
inst✝⁴ : Module R V
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V₁
inst✝ : Module K V₁
s : Set V
hs : Set.Finite s
⊢ Module.rank R ↥(span R s) ≤ #↑s

Next tactic:
rw [Module.rank_def]
theorem rank_span_le_of_finite {s : Set V} (hs : s.Finite) : Module.rank R (span R s) ≤ #s := by
  rw [Module.rank_def]
  

Proof state:
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁹ : DivisionRing K
inst✝⁸ : Ring R
inst✝⁷ : StrongRankCondition R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module K V
inst✝⁴ : Module R V
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V₁
inst✝ : Module K V₁
s : Set V
hs : Set.Finite s
⊢ ⨆ ι, #↑↑ι ≤ #↑s

Next tactic:
apply ciSup_le'
theorem rank_span_le_of_finite {s : Set V} (hs : s.Finite) : Module.rank R (span R s) ≤ #s := by
  rw [Module.rank_def]
  apply ciSup_le'
  

Proof state:
case h
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁹ : DivisionRing K
inst✝⁸ : Ring R
inst✝⁷ : StrongRankCondition R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module K V
inst✝⁴ : Module R V
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V₁
inst✝ : Module K V₁
s : Set V
hs : Set.Finite s
⊢ ∀ (i : { s_1 // LinearIndependent (ι := { x // x ∈ s_1 }) R Subtype.val }), #↑↑i ≤ #↑s

Next tactic:
rintro ⟨t, ht⟩
theorem rank_span_le_of_finite {s : Set V} (hs : s.Finite) : Module.rank R (span R s) ≤ #s := by
  rw [Module.rank_def]
  apply ciSup_le'
  rintro ⟨t, ht⟩
  

Proof state:
case h.mk
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁹ : DivisionRing K
inst✝⁸ : Ring R
inst✝⁷ : StrongRankCondition R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module K V
inst✝⁴ : Module R V
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V₁
inst✝ : Module K V₁
s : Set V
hs : Set.Finite s
t : Set ↥(span R s)
ht : LinearIndependent (ι := { x // x ∈ t }) R Subtype.val
⊢ #↑↑{ val := t, property := ht } ≤ #↑s

Next tactic:
letI := hs.fintype
theorem rank_span_le_of_finite {s : Set V} (hs : s.Finite) : Module.rank R (span R s) ≤ #s := by
  rw [Module.rank_def]
  apply ciSup_le'
  rintro ⟨t, ht⟩
  letI := hs.fintype
  

Proof state:
case h.mk
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁹ : DivisionRing K
inst✝⁸ : Ring R
inst✝⁷ : StrongRankCondition R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module K V
inst✝⁴ : Module R V
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V₁
inst✝ : Module K V₁
s : Set V
hs : Set.Finite s
t : Set ↥(span R s)
ht : LinearIndependent (ι := { x // x ∈ t }) R Subtype.val
this : Fintype ↑s := Finite.fintype hs
⊢ #↑↑{ val := t, property := ht } ≤ #↑s

Next tactic:
simpa [Cardinal.mk_image_eq Subtype.val_injective] using linearIndependent_le_span' _
    (ht.map (f := Submodule.subtype _) (by simp)).image s (fun x ↦ by aesop)
theorem rank_span_le_of_finite {s : Set V} (hs : s.Finite) : Module.rank R (span R s) ≤ #s := by
  rw [Module.rank_def]
  apply ciSup_le'
  rintro ⟨t, ht⟩
  letI := hs.fintype
  simpa [Cardinal.mk_image_eq Subtype.val_injective] using linearIndependent_le_span' _
    (ht.map (f := Submodule.subtype _) (by 

Proof state:
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁹ : DivisionRing K
inst✝⁸ : Ring R
inst✝⁷ : StrongRankCondition R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module K V
inst✝⁴ : Module R V
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V₁
inst✝ : Module K V₁
s : Set V
hs : Set.Finite s
t : Set ↥(span R s)
ht : LinearIndependent (ι := { x // x ∈ t }) R Subtype.val
this : Fintype ↑s := Finite.fintype hs
⊢ Disjoint (span R (range Subtype.val)) (LinearMap.ker (Submodule.subtype (span R s)))

Next tactic:
simp
theorem rank_span_le_of_finite {s : Set V} (hs : s.Finite) : Module.rank R (span R s) ≤ #s := by
  rw [Module.rank_def]
  apply ciSup_le'
  rintro ⟨t, ht⟩
  letI := hs.fintype
  simpa [Cardinal.mk_image_eq Subtype.val_injective] using linearIndependent_le_span' _
    (ht.map (f := Submodule.subtype _) (by simp)).image s (fun x ↦ by 

Proof state:
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁹ : DivisionRing K
inst✝⁸ : Ring R
inst✝⁷ : StrongRankCondition R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module K V
inst✝⁴ : Module R V
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V₁
inst✝ : Module K V₁
s : Set V
hs : Set.Finite s
t : Set ↥(span R s)
ht : LinearIndependent (ι := { x // x ∈ t }) R Subtype.val
this : Fintype ↑s := Finite.fintype hs
x : V
⊢ (x ∈ range fun x => ↑x) → x ∈ ↑(span R s)

Next tactic:
aesop
theorem rank_span_finset_le (s : Finset V) : Module.rank R (span R (s : Set V)) ≤ s.card := by
  

Proof state:
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁹ : DivisionRing K
inst✝⁸ : Ring R
inst✝⁷ : StrongRankCondition R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module K V
inst✝⁴ : Module R V
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V₁
inst✝ : Module K V₁
s : Finset V
⊢ Module.rank R ↥(span R ↑s) ≤ ↑(Finset.card s)

Next tactic:
simpa using rank_span_le_of_finite s.finite_toSet
theorem rank_quotient_add_rank (p : Submodule K V) :
    Module.rank K (V ⧸ p) + Module.rank K p = Module.rank K V := by
  

Proof state:
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁹ : DivisionRing K
inst✝⁸ : Ring R
inst✝⁷ : StrongRankCondition R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module K V
inst✝⁴ : Module R V
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V₁
inst✝ : Module K V₁
p : Submodule K V
⊢ Module.rank K (V ⧸ p) + Module.rank K ↥p = Module.rank K V

Next tactic:
classical
    let ⟨f⟩ := quotient_prod_linearEquiv p
    exact rank_prod'.symm.trans f.rank_eq
theorem rank_quotient_add_rank (p : Submodule K V) :
    Module.rank K (V ⧸ p) + Module.rank K p = Module.rank K V := by
  classical
    

Proof state:
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁹ : DivisionRing K
inst✝⁸ : Ring R
inst✝⁷ : StrongRankCondition R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module K V
inst✝⁴ : Module R V
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V₁
inst✝ : Module K V₁
p : Submodule K V
⊢ Module.rank K (V ⧸ p) + Module.rank K ↥p = Module.rank K V

Next tactic:
let ⟨f⟩ := quotient_prod_linearEquiv p
theorem rank_quotient_add_rank (p : Submodule K V) :
    Module.rank K (V ⧸ p) + Module.rank K p = Module.rank K V := by
  classical
    let ⟨f⟩ := quotient_prod_linearEquiv p
    

Proof state:
K R : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁹ : DivisionRing K
inst✝⁸ : Ring R
inst✝⁷ : StrongRankCondition R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module K V
inst✝⁴ : Module R V
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V₁
inst✝ : Module K V₁
p : Submodule K V
f : ((V ⧸ p) × ↥p) ≃ₗ[K] V
⊢ Module.rank K (V ⧸ p) + Module.rank K ↥p = Module.rank K V

Next tactic:
exact rank_prod'.symm.trans f.rank_eq