Theorem: finrank_vectorSpan_insert_le
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: by_cases hf : FiniteDimensional k s.direction
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
⊢ finrank k { x // x ∈ vectorSpan k (insert p ↑s) } ≤ finrank k { x // x ∈ direction s } + 1

tactic: swap
state_before: case pos
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf : FiniteDimensional k { x // x ∈ direction s }
⊢ finrank k { x // x ∈ vectorSpan k (insert p ↑s) } ≤ finrank k { x // x ∈ direction s } + 1

case neg
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf : ¬FiniteDimensional k { x // x ∈ direction s }
⊢ finrank k { x // x ∈ vectorSpan k (insert p ↑s) } ≤ finrank k { x // x ∈ direction s } + 1

tactic: have : FiniteDimensional k s.direction := hf
state_before: case pos
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf : FiniteDimensional k { x // x ∈ direction s }
⊢ finrank k { x // x ∈ vectorSpan k (insert p ↑s) } ≤ finrank k { x // x ∈ direction s } + 1

tactic: rw [← direction_affineSpan, ← affineSpan_insert_affineSpan]
state_before: case pos
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf this : FiniteDimensional k { x // x ∈ direction s }
⊢ finrank k { x // x ∈ vectorSpan k (insert p ↑s) } ≤ finrank k { x // x ∈ direction s } + 1

tactic: rcases (s : Set P).eq_empty_or_nonempty with (hs | ⟨p₀, hp₀⟩)
state_before: case pos
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf this : FiniteDimensional k { x // x ∈ direction s }
⊢ finrank k { x // x ∈ direction (affineSpan k (insert p ↑(affineSpan k ↑s))) } ≤ finrank k { x // x ∈ direction s } + 1

tactic: have hf' : ¬FiniteDimensional k (vectorSpan k (insert p (s : Set P))) := by
  intro h
  have h' : s.direction ≤ vectorSpan k (insert p (s : Set P)) := by
    conv_lhs => rw [← affineSpan_coe s, direction_affineSpan]
    exact vectorSpan_mono k (Set.subset_insert _ _)
  exact hf (Submodule.finiteDimensional_of_le h')
state_before: case neg
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf : ¬FiniteDimensional k { x // x ∈ direction s }
⊢ finrank k { x // x ∈ vectorSpan k (insert p ↑s) } ≤ finrank k { x // x ∈ direction s } + 1

tactic: rw [finrank_of_infinite_dimensional hf, finrank_of_infinite_dimensional hf', zero_add]
state_before: case neg
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf : ¬FiniteDimensional k { x // x ∈ direction s }
hf' : ¬FiniteDimensional k { x // x ∈ vectorSpan k (insert p ↑s) }
⊢ finrank k { x // x ∈ vectorSpan k (insert p ↑s) } ≤ finrank k { x // x ∈ direction s } + 1

tactic: exact zero_le_one
state_before: case neg
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf : ¬FiniteDimensional k { x // x ∈ direction s }
hf' : ¬FiniteDimensional k { x // x ∈ vectorSpan k (insert p ↑s) }
⊢ 0 ≤ 1

tactic: intro h
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf : ¬FiniteDimensional k { x // x ∈ direction s }
⊢ ¬FiniteDimensional k { x // x ∈ vectorSpan k (insert p ↑s) }

tactic: have h' : s.direction ≤ vectorSpan k (insert p (s : Set P)) := by
  conv_lhs => rw [← affineSpan_coe s, direction_affineSpan]
  exact vectorSpan_mono k (Set.subset_insert _ _)
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf : ¬FiniteDimensional k { x // x ∈ direction s }
h : FiniteDimensional k { x // x ∈ vectorSpan k (insert p ↑s) }
⊢ False

tactic: exact hf (Submodule.finiteDimensional_of_le h')
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf : ¬FiniteDimensional k { x // x ∈ direction s }
h : FiniteDimensional k { x // x ∈ vectorSpan k (insert p ↑s) }
h' : direction s ≤ vectorSpan k (insert p ↑s)
⊢ False

tactic: conv_lhs => rw [← affineSpan_coe s, direction_affineSpan]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf : ¬FiniteDimensional k { x // x ∈ direction s }
h : FiniteDimensional k { x // x ∈ vectorSpan k (insert p ↑s) }
⊢ direction s ≤ vectorSpan k (insert p ↑s)

tactic: exact vectorSpan_mono k (Set.subset_insert _ _)
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf : ¬FiniteDimensional k { x // x ∈ direction s }
h : FiniteDimensional k { x // x ∈ vectorSpan k (insert p ↑s) }
⊢ vectorSpan k ↑s ≤ vectorSpan k (insert p ↑s)

tactic: rw [coe_eq_bot_iff] at hs
state_before: case pos.inl
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf this : FiniteDimensional k { x // x ∈ direction s }
hs : ↑s = ∅
⊢ finrank k { x // x ∈ direction (affineSpan k (insert p ↑(affineSpan k ↑s))) } ≤ finrank k { x // x ∈ direction s } + 1

tactic: rw [hs, bot_coe, span_empty, bot_coe, direction_affineSpan, direction_bot, finrank_bot,
  zero_add]
state_before: case pos.inl
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf this : FiniteDimensional k { x // x ∈ direction s }
hs : s = ⊥
⊢ finrank k { x // x ∈ direction (affineSpan k (insert p ↑(affineSpan k ↑s))) } ≤ finrank k { x // x ∈ direction s } + 1

tactic: convert zero_le_one' ℕ
state_before: case pos.inl
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf this : FiniteDimensional k { x // x ∈ direction s }
hs : s = ⊥
⊢ finrank k { x // x ∈ vectorSpan k (insert p ∅) } ≤ 1

tactic: rw [← finrank_bot k V]
state_before: case h.e'_3
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf this : FiniteDimensional k { x // x ∈ direction s }
hs : s = ⊥
⊢ finrank k { x // x ∈ vectorSpan k (insert p ∅) } = 0

tactic: convert rfl <;> simp
state_before: case h.e'_3
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf this : FiniteDimensional k { x // x ∈ direction s }
hs : s = ⊥
⊢ finrank k { x // x ∈ vectorSpan k (insert p ∅) } = finrank k { x // x ∈ ⊥ }

tactic: rw [affineSpan_coe, direction_affineSpan_insert hp₀, add_comm]
state_before: case pos.inr.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf this : FiniteDimensional k { x // x ∈ direction s }
p₀ : P
hp₀ : p₀ ∈ ↑s
⊢ finrank k { x // x ∈ direction (affineSpan k (insert p ↑(affineSpan k ↑s))) } ≤ finrank k { x // x ∈ direction s } + 1

tactic: refine' (Submodule.finrank_add_le_finrank_add_finrank _ _).trans (add_le_add_right _ _)
state_before: case pos.inr.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf this : FiniteDimensional k { x // x ∈ direction s }
p₀ : P
hp₀ : p₀ ∈ ↑s
⊢ finrank k { x // x ∈ Submodule.span k {p -ᵥ p₀} ⊔ direction s } ≤ 1 + finrank k { x // x ∈ direction s }

tactic: refine' finrank_le_one ⟨p -ᵥ p₀, Submodule.mem_span_singleton_self _⟩ fun v => _
state_before: case pos.inr.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf this : FiniteDimensional k { x // x ∈ direction s }
p₀ : P
hp₀ : p₀ ∈ ↑s
⊢ finrank k { x // x ∈ Submodule.span k {p -ᵥ p₀} } ≤ 1

tactic: have h := v.property
state_before: case pos.inr.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf this : FiniteDimensional k { x // x ∈ direction s }
p₀ : P
hp₀ : p₀ ∈ ↑s
v : { x // x ∈ Submodule.span k {p -ᵥ p₀} }
⊢ ∃ c, c • { val := p -ᵥ p₀, property := (_ : p -ᵥ p₀ ∈ Submodule.span k {p -ᵥ p₀}) } = v

tactic: rw [Submodule.mem_span_singleton] at h
state_before: case pos.inr.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf this : FiniteDimensional k { x // x ∈ direction s }
p₀ : P
hp₀ : p₀ ∈ ↑s
v : { x // x ∈ Submodule.span k {p -ᵥ p₀} }
h : ↑v ∈ Submodule.span k {p -ᵥ p₀}
⊢ ∃ c, c • { val := p -ᵥ p₀, property := (_ : p -ᵥ p₀ ∈ Submodule.span k {p -ᵥ p₀}) } = v

tactic: rcases h with ⟨c, hc⟩
state_before: case pos.inr.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf this : FiniteDimensional k { x // x ∈ direction s }
p₀ : P
hp₀ : p₀ ∈ ↑s
v : { x // x ∈ Submodule.span k {p -ᵥ p₀} }
h : ∃ a, a • (p -ᵥ p₀) = ↑v
⊢ ∃ c, c • { val := p -ᵥ p₀, property := (_ : p -ᵥ p₀ ∈ Submodule.span k {p -ᵥ p₀}) } = v

tactic: refine' ⟨c, _⟩
state_before: case pos.inr.intro.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf this : FiniteDimensional k { x // x ∈ direction s }
p₀ : P
hp₀ : p₀ ∈ ↑s
v : { x // x ∈ Submodule.span k {p -ᵥ p₀} }
c : k
hc : c • (p -ᵥ p₀) = ↑v
⊢ ∃ c, c • { val := p -ᵥ p₀, property := (_ : p -ᵥ p₀ ∈ Submodule.span k {p -ᵥ p₀}) } = v

tactic: ext
state_before: case pos.inr.intro.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf this : FiniteDimensional k { x // x ∈ direction s }
p₀ : P
hp₀ : p₀ ∈ ↑s
v : { x // x ∈ Submodule.span k {p -ᵥ p₀} }
c : k
hc : c • (p -ᵥ p₀) = ↑v
⊢ c • { val := p -ᵥ p₀, property := (_ : p -ᵥ p₀ ∈ Submodule.span k {p -ᵥ p₀}) } = v

tactic: exact hc
state_before: case pos.inr.intro.intro.a
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hf this : FiniteDimensional k { x // x ∈ direction s }
p₀ : P
hp₀ : p₀ ∈ ↑s
v : { x // x ∈ Submodule.span k {p -ᵥ p₀} }
c : k
hc : c • (p -ᵥ p₀) = ↑v
⊢ ↑(c • { val := p -ᵥ p₀, property := (_ : p -ᵥ p₀ ∈ Submodule.span k {p -ᵥ p₀}) }) = ↑v