File: Mathlib/LinearAlgebra/Basis/Flag.lean

full_name: Basis.flag
code: /-- The subspace spanned by the first `k` vectors of the basis `b`. -/
def flag (b : Basis (Fin n) R M) (k : Fin (n + 1)) : Submodule R M 
goal: Submodule R M

full_name: Basis.flag_zero
code: @[simp]
theorem flag_zero (b : Basis (Fin n) R M) : b.flag 0 = ⊥ 
goal: b.flag 0 = ⊥

full_name: Basis.flag_last
code: @[simp]
theorem flag_last (b : Basis (Fin n) R M) : b.flag (.last n) = ⊤ 
goal: b.flag (Fin.last n) = ⊤

full_name: Basis.flag_le_iff
code: theorem flag_le_iff (b : Basis (Fin n) R M) {k p} :
    b.flag k ≤ p ↔ ∀ i : Fin n, i.castSucc < k → b i ∈ p 
goal: b.flag k ≤ p ↔ ∀ (i : Fin n), i.castSucc < k → b i ∈ p

full_name: Basis.flag_succ
code: theorem flag_succ (b : Basis (Fin n) R M) (k : Fin n) :
    b.flag k.succ = (R ∙ b k) ⊔ b.flag k.castSucc 
goal: b.flag k.succ = Submodule.span R {b k} ⊔ b.flag k.castSucc

full_name: Basis.self_mem_flag
code: theorem self_mem_flag (b : Basis (Fin n) R M) {i : Fin n} {k : Fin (n + 1)} (h : i.castSucc < k) :
    b i ∈ b.flag k 
goal: b i ∈ b.flag k

full_name: Basis.self_mem_flag_iff
code: @[simp]
theorem self_mem_flag_iff [Nontrivial R] (b : Basis (Fin n) R M) {i : Fin n} {k : Fin (n + 1)} :
    b i ∈ b.flag k ↔ i.castSucc < k 
goal: b i ∈ b.flag k ↔ i.castSucc < k

full_name: Basis.flag_mono
code: @[mono]
theorem flag_mono (b : Basis (Fin n) R M) : Monotone b.flag 
goal: Monotone b.flag

full_name: Basis.isChain_range_flag
code: theorem isChain_range_flag (b : Basis (Fin n) R M) : IsChain (· ≤ ·) (range b.flag) 
goal: IsChain (fun x x_1 => x ≤ x_1) (Set.range b.flag)

full_name: Basis.flag_strictMono
code: @[mono]
theorem flag_strictMono [Nontrivial R] (b : Basis (Fin n) R M) : StrictMono b.flag 
goal: StrictMono b.flag

full_name: Basis.flag_le_ker_coord_iff
code: @[simp]
theorem flag_le_ker_coord_iff [Nontrivial R] (b : Basis (Fin n) R M) {k : Fin (n + 1)} {l : Fin n} :
    b.flag k ≤ LinearMap.ker (b.coord l) ↔ k ≤ l.castSucc 
goal: b.flag k ≤ LinearMap.ker (b.coord l) ↔ k ≤ l.castSucc

full_name: Basis.flag_le_ker_coord
code: theorem flag_le_ker_coord (b : Basis (Fin n) R M) {k : Fin (n + 1)} {l : Fin n}
    (h : k ≤ l.castSucc) : b.flag k ≤ LinearMap.ker (b.coord l) 
goal: b.flag k ≤ LinearMap.ker (b.coord l)

full_name: Basis.flag_le_ker_dual
code: theorem flag_le_ker_dual (b : Basis (Fin n) R M) (k : Fin n) :
    b.flag k.castSucc ≤ LinearMap.ker (b.dualBasis k) 
goal: b.flag k.castSucc ≤ LinearMap.ker (b.dualBasis k)

full_name: Basis.flag_covBy
code: theorem flag_covBy (b : Basis (Fin n) K V) (i : Fin n) :
    b.flag i.castSucc ⋖ b.flag i.succ 
goal: b.flag i.castSucc ⋖ b.flag i.succ

full_name: Basis.flag_wcovBy
code: theorem flag_wcovBy (b : Basis (Fin n) K V) (i : Fin n) :
    b.flag i.castSucc ⩿ b.flag i.succ 
goal: b.flag i.castSucc ⩿ b.flag i.succ

full_name: Basis.toFlag_carrier
code: /-- Range of `Basis.flag` as a `Flag`. -/
@[simps!]
def toFlag (b : Basis (Fin n) K V) : Flag (Submodule K V) 
goal: ↑b.toFlag = Set.range b.flag

full_name: Basis.toFlag
code: /-- Range of `Basis.flag` as a `Flag`. -/
@[simps!]
def toFlag (b : Basis (Fin n) K V) : Flag (Submodule K V) 
goal: Flag (Submodule K V)

full_name: Basis.mem_toFlag
code: @[simp]
theorem mem_toFlag (b : Basis (Fin n) K V) {p : Submodule K V} : p ∈ b.toFlag ↔ ∃ k, b.flag k = p 
goal: p ∈ b.toFlag ↔ ∃ k, b.flag k = p

full_name: Basis.isMaxChain_range_flag
code: theorem isMaxChain_range_flag (b : Basis (Fin n) K V) : IsMaxChain (· ≤ ·) (range b.flag) 
goal: IsMaxChain (fun x x_1 => x ≤ x_1) (Set.range b.flag)