File: Mathlib/Data/Matroid/Constructions.lean

full_name: Matroid.emptyOn
code: /-- The `Matroid α` with empty ground set. -/
def emptyOn (α : Type*) : Matroid α 
goal: Matroid α

full_name: Matroid.emptyOn_ground
code: @[simp] theorem emptyOn_ground : (emptyOn α).E = ∅ 
goal: (Matroid.emptyOn α).E = ∅

full_name: Matroid.emptyOn_base_iff
code: @[simp] theorem emptyOn_base_iff : (emptyOn α).Base B ↔ B = ∅ 
goal: (Matroid.emptyOn α).Base B ↔ B = ∅

full_name: Matroid.emptyOn_indep_iff
code: @[simp] theorem emptyOn_indep_iff : (emptyOn α).Indep I ↔ I = ∅ 
goal: (Matroid.emptyOn α).Indep I ↔ I = ∅

full_name: Matroid.ground_eq_empty_iff
code: theorem ground_eq_empty_iff : (M.E = ∅) ↔ M = emptyOn α 
goal: M.E = ∅ ↔ M = Matroid.emptyOn α

full_name: Matroid.emptyOn_dual_eq
code: @[simp] theorem emptyOn_dual_eq : (emptyOn α)✶ = emptyOn α 
goal: (Matroid.emptyOn α)✶ = Matroid.emptyOn α

full_name: Matroid.restrict_empty
code: @[simp] theorem restrict_empty (M : Matroid α) : M ↾ (∅ : Set α) = emptyOn α 
goal: M.restrict ∅ = Matroid.emptyOn α

full_name: Matroid.eq_emptyOn_or_nonempty
code: theorem eq_emptyOn_or_nonempty (M : Matroid α) : M = emptyOn α ∨ Matroid.Nonempty M 
goal: M = Matroid.emptyOn α ∨ M.Nonempty

full_name: Matroid.eq_emptyOn
code: theorem eq_emptyOn [IsEmpty α] (M : Matroid α) : M = emptyOn α 
goal: M = Matroid.emptyOn α

full_name: Matroid.finite_emptyOn
code: instance finite_emptyOn (α : Type*) : (emptyOn α).Finite 
goal: (Matroid.emptyOn α).Finite

full_name: Matroid.loopyOn
code: /-- The `Matroid α` with ground set `E` whose only base is `∅` -/
def loopyOn (E : Set α) : Matroid α 
goal: Matroid α

full_name: Matroid.loopyOn_ground
code: @[simp] theorem loopyOn_ground (E : Set α) : (loopyOn E).E = E 
goal: (Matroid.loopyOn E).E = E

full_name: Matroid.loopyOn_empty
code: @[simp] theorem loopyOn_empty (α : Type*) : loopyOn (∅ : Set α) = emptyOn α 
goal: Matroid.loopyOn ∅ = Matroid.emptyOn α

full_name: Matroid.loopyOn_indep_iff
code: @[simp] theorem loopyOn_indep_iff : (loopyOn E).Indep I ↔ I = ∅ 
goal: (Matroid.loopyOn E).Indep I ↔ I = ∅

full_name: Matroid.eq_loopyOn_iff
code: theorem eq_loopyOn_iff : M = loopyOn E ↔ M.E = E ∧ ∀ X ⊆ M.E, M.Indep X → X = ∅ 
goal: M = Matroid.loopyOn E ↔ M.E = E ∧ ∀ X ⊆ M.E, M.Indep X → X = ∅

full_name: Matroid.loopyOn_base_iff
code: @[simp] theorem loopyOn_base_iff : (loopyOn E).Base B ↔ B = ∅ 
goal: (Matroid.loopyOn E).Base B ↔ B = ∅

full_name: Matroid.loopyOn_basis_iff
code: @[simp] theorem loopyOn_basis_iff : (loopyOn E).Basis I X ↔ I = ∅ ∧ X ⊆ E 
goal: (Matroid.loopyOn E).Basis I X ↔ I = ∅ ∧ X ⊆ E

full_name: Matroid.instFiniteRkLoopyOn
code: instance : FiniteRk (loopyOn E) 
goal: (Matroid.loopyOn E).FiniteRk

full_name: Matroid.Finite.loopyOn_finite
code: theorem Finite.loopyOn_finite (hE : E.Finite) : Matroid.Finite (loopyOn E) 
goal: (Matroid.loopyOn E).Finite

full_name: Matroid.loopyOn_restrict
code: @[simp] theorem loopyOn_restrict (E R : Set α) : (loopyOn E) ↾ R = loopyOn R 
goal: (Matroid.loopyOn E).restrict R = Matroid.loopyOn R

full_name: Matroid.empty_base_iff
code: theorem empty_base_iff : M.Base ∅ ↔ M = loopyOn M.E 
goal: M.Base ∅ ↔ M = Matroid.loopyOn M.E

full_name: Matroid.eq_loopyOn_or_rkPos
code: theorem eq_loopyOn_or_rkPos (M : Matroid α) : M = loopyOn M.E ∨ RkPos M 
goal: M = Matroid.loopyOn M.E ∨ M.RkPos

full_name: Matroid.not_rkPos_iff
code: theorem not_rkPos_iff : ¬RkPos M ↔ M = loopyOn M.E 
goal: ¬M.RkPos ↔ M = Matroid.loopyOn M.E

full_name: Matroid.freeOn
code: /-- The `Matroid α` with ground set `E` whose only base is `E`. -/
def freeOn (E : Set α) : Matroid α 
goal: Matroid α

full_name: Matroid.freeOn_ground
code: @[simp] theorem freeOn_ground : (freeOn E).E = E 
goal: (Matroid.freeOn E).E = E

full_name: Matroid.freeOn_dual_eq
code: @[simp] theorem freeOn_dual_eq : (freeOn E)✶ = loopyOn E 
goal: (Matroid.freeOn E)✶ = Matroid.loopyOn E

full_name: Matroid.loopyOn_dual_eq
code: @[simp] theorem loopyOn_dual_eq : (loopyOn E)✶ = freeOn E 
goal: (Matroid.loopyOn E)✶ = Matroid.freeOn E

full_name: Matroid.freeOn_empty
code: @[simp] theorem freeOn_empty (α : Type*) : freeOn (∅ : Set α) = emptyOn α 
goal: Matroid.freeOn ∅ = Matroid.emptyOn α

full_name: Matroid.freeOn_base_iff
code: @[simp] theorem freeOn_base_iff : (freeOn E).Base B ↔ B = E 
goal: (Matroid.freeOn E).Base B ↔ B = E

full_name: Matroid.freeOn_indep_iff
code: @[simp] theorem freeOn_indep_iff : (freeOn E).Indep I ↔ I ⊆ E 
goal: (Matroid.freeOn E).Indep I ↔ I ⊆ E

full_name: Matroid.freeOn_indep
code: theorem freeOn_indep (hIE : I ⊆ E) : (freeOn E).Indep I 
goal: (Matroid.freeOn E).Indep I

full_name: Matroid.freeOn_basis_iff
code: @[simp] theorem freeOn_basis_iff : (freeOn E).Basis I X ↔ I = X ∧ X ⊆ E 
goal: (Matroid.freeOn E).Basis I X ↔ I = X ∧ X ⊆ E

full_name: Matroid.freeOn_basis'_iff
code: @[simp] theorem freeOn_basis'_iff : (freeOn E).Basis' I X ↔ I = X ∩ E 
goal: (Matroid.freeOn E).Basis' I X ↔ I = X ∩ E

full_name: Matroid.eq_freeOn_iff
code: theorem eq_freeOn_iff : M = freeOn E ↔ M.E = E ∧ M.Indep E 
goal: M = Matroid.freeOn E ↔ M.E = E ∧ M.Indep E

full_name: Matroid.ground_indep_iff_eq_freeOn
code: theorem ground_indep_iff_eq_freeOn : M.Indep M.E ↔ M = freeOn M.E 
goal: M.Indep M.E ↔ M = Matroid.freeOn M.E

full_name: Matroid.freeOn_restrict
code: theorem freeOn_restrict (h : R ⊆ E) : (freeOn E) ↾ R = freeOn R 
goal: (Matroid.freeOn E).restrict R = Matroid.freeOn R

full_name: Matroid.restrict_eq_freeOn_iff
code: theorem restrict_eq_freeOn_iff : M ↾ I = freeOn I ↔ M.Indep I 
goal: M.restrict I = Matroid.freeOn I ↔ M.Indep I

full_name: Matroid.Indep.restrict_eq_freeOn
code: theorem Indep.restrict_eq_freeOn (hI : M.Indep I) : M ↾ I = freeOn I 
goal: M.restrict I = Matroid.freeOn I

full_name: Matroid.uniqueBaseOn
code: /-- The matroid on `E` whose unique base is the subset `I` of `E`.
Intended for use when `I ⊆ E`; if this not not the case, then the base is `I ∩ E`. -/
def uniqueBaseOn (I E : Set α) : Matroid α 
goal: Matroid α

full_name: Matroid.uniqueBaseOn_ground
code: @[simp] theorem uniqueBaseOn_ground : (uniqueBaseOn I E).E = E 
goal: (Matroid.uniqueBaseOn I E).E = E

full_name: Matroid.uniqueBaseOn_base_iff
code: theorem uniqueBaseOn_base_iff (hIE : I ⊆ E) : (uniqueBaseOn I E).Base B ↔ B = I 
goal: (Matroid.uniqueBaseOn I E).Base B ↔ B = I

full_name: Matroid.uniqueBaseOn_inter_ground_eq
code: theorem uniqueBaseOn_inter_ground_eq (I E : Set α) :
    uniqueBaseOn (I ∩ E) E = uniqueBaseOn I E 
goal: Matroid.uniqueBaseOn (I ∩ E) E = Matroid.uniqueBaseOn I E

full_name: Matroid.uniqueBaseOn_indep_iff'
code: @[simp] theorem uniqueBaseOn_indep_iff' : (uniqueBaseOn I E).Indep J ↔ J ⊆ I ∩ E 
goal: (Matroid.uniqueBaseOn I E).Indep J ↔ J ⊆ I ∩ E

full_name: Matroid.uniqueBaseOn_indep_iff
code: theorem uniqueBaseOn_indep_iff (hIE : I ⊆ E) : (uniqueBaseOn I E).Indep J ↔ J ⊆ I 
goal: (Matroid.uniqueBaseOn I E).Indep J ↔ J ⊆ I

full_name: Matroid.uniqueBaseOn_basis_iff
code: theorem uniqueBaseOn_basis_iff (hI : I ⊆ E) (hX : X ⊆ E) :
    (uniqueBaseOn I E).Basis J X ↔ J = X ∩ I 
goal: (Matroid.uniqueBaseOn I E).Basis J X ↔ J = X ∩ I

full_name: Matroid.uniqueBaseOn_inter_basis
code: theorem uniqueBaseOn_inter_basis (hI : I ⊆ E) (hX : X ⊆ E) :
    (uniqueBaseOn I E).Basis (X ∩ I) X 
goal: (Matroid.uniqueBaseOn I E).Basis (X ∩ I) X

full_name: Matroid.uniqueBaseOn_dual_eq
code: @[simp] theorem uniqueBaseOn_dual_eq (I E : Set α) :
    (uniqueBaseOn I E)✶ = uniqueBaseOn (E \ I) E 
goal: (Matroid.uniqueBaseOn I E)✶ = Matroid.uniqueBaseOn (E \ I) E

full_name: Matroid.uniqueBaseOn_self
code: @[simp] theorem uniqueBaseOn_self (I : Set α) : uniqueBaseOn I I = freeOn I 
goal: Matroid.uniqueBaseOn I I = Matroid.freeOn I

full_name: Matroid.uniqueBaseOn_empty
code: @[simp] theorem uniqueBaseOn_empty (I : Set α) : uniqueBaseOn ∅ I = loopyOn I 
goal: Matroid.uniqueBaseOn ∅ I = Matroid.loopyOn I

full_name: Matroid.uniqueBaseOn_restrict'
code: theorem uniqueBaseOn_restrict' (I E R : Set α) :
    (uniqueBaseOn I E) ↾ R = uniqueBaseOn (I ∩ R ∩ E) R 
goal: (Matroid.uniqueBaseOn I E).restrict R = Matroid.uniqueBaseOn (I ∩ R ∩ E) R

full_name: Matroid.uniqueBaseOn_restrict
code: theorem uniqueBaseOn_restrict (h : I ⊆ E) (R : Set α) :
    (uniqueBaseOn I E) ↾ R = uniqueBaseOn (I ∩ R) R 
goal: (Matroid.uniqueBaseOn I E).restrict R = Matroid.uniqueBaseOn (I ∩ R) R