File: Mathlib/Data/Matroid/Map.lean

full_name: Matroid.comap
code: /-- The pullback of a matroid on `β` by a function `f : α → β` to a matroid on `α`.
Elements with the same (nonloop) image are parallel and the ground set is `f ⁻¹' M.E`.
The matroids `M.comap f` and `M ↾ range f` have isomorphic simplifications;
the preimage of each nonloop of `M ↾ range f` is a parallel class. -/
def comap (N : Matroid β) (f : α → β) : Matroid α 
goal: Matroid α

full_name: Matroid.comap_indep_iff
code: @[simp] lemma comap_indep_iff : (N.comap f).Indep I ↔ N.Indep (f '' I) ∧ InjOn f I 
goal: (N.comap f).Indep I ↔ N.Indep (f '' I) ∧ Set.InjOn f I

full_name: Matroid.comap_ground_eq
code: @[simp] lemma comap_ground_eq (N : Matroid β) (f : α → β) : (N.comap f).E = f ⁻¹' N.E 
goal: (N.comap f).E = f ⁻¹' N.E

full_name: Matroid.comap_dep_iff
code: @[simp] lemma comap_dep_iff :
    (N.comap f).Dep I ↔ N.Dep (f '' I) ∨ (N.Indep (f '' I) ∧ ¬ InjOn f I) 
goal: (N.comap f).Dep I ↔ N.Dep (f '' I) ∨ N.Indep (f '' I) ∧ ¬Set.InjOn f I

full_name: Matroid.comap_id
code: @[simp] lemma comap_id (N : Matroid β) : N.comap id = N 
goal: N.comap id = N

full_name: Matroid.comap_indep_iff_of_injOn
code: lemma comap_indep_iff_of_injOn (hf : InjOn f (f ⁻¹' N.E)) :
    (N.comap f).Indep I ↔ N.Indep (f '' I) 
goal: (N.comap f).Indep I ↔ N.Indep (f '' I)

full_name: Matroid.comap_emptyOn
code: @[simp] lemma comap_emptyOn (f : α → β) : comap (emptyOn β) f = emptyOn α 
goal: (Matroid.emptyOn β).comap f = Matroid.emptyOn α

full_name: Matroid.comap_loopyOn
code: @[simp] lemma comap_loopyOn (f : α → β) (E : Set β) : comap (loopyOn E) f = loopyOn (f ⁻¹' E) 
goal: (Matroid.loopyOn E).comap f = Matroid.loopyOn (f ⁻¹' E)

full_name: Matroid.comap_basis_iff
code: @[simp] lemma comap_basis_iff {I X : Set α} :
    (N.comap f).Basis I X ↔ N.Basis (f '' I) (f '' X) ∧ I.InjOn f ∧ I ⊆ X  
goal: (N.comap f).Basis I X ↔ N.Basis (f '' I) (f '' X) ∧ Set.InjOn f I ∧ I ⊆ X

full_name: Matroid.comap_base_iff
code: @[simp] lemma comap_base_iff {B : Set α} :
    (N.comap f).Base B ↔ N.Basis (f '' B) (f '' (f ⁻¹' N.E)) ∧ B.InjOn f ∧ B ⊆ f ⁻¹' N.E 
goal: (N.comap f).Base B ↔ N.Basis (f '' B) (f '' (f ⁻¹' N.E)) ∧ Set.InjOn f B ∧ B ⊆ f ⁻¹' N.E

full_name: Matroid.comap_basis'_iff
code: @[simp] lemma comap_basis'_iff {I X : Set α} :
    (N.comap f).Basis' I X ↔ N.Basis' (f '' I) (f '' X) ∧ I.InjOn f ∧ I ⊆ X 
goal: (N.comap f).Basis' I X ↔ N.Basis' (f '' I) (f '' X) ∧ Set.InjOn f I ∧ I ⊆ X

full_name: Matroid.comap_finitary
code: instance comap_finitary (N : Matroid β) [N.Finitary] (f : α → β) : (N.comap f).Finitary 
goal: (N.comap f).Finitary

full_name: Matroid.comap_finiteRk
code: instance comap_finiteRk (N : Matroid β) [N.FiniteRk] (f : α → β) : (N.comap f).FiniteRk 
goal: (N.comap f).FiniteRk

full_name: Matroid.comapOn
code: /-- The pullback of a matroid on `β` by a function `f : α → β` to a matroid on `α`,
restricted to a ground set `E`.
The matroids `M.comapOn f E` and `M ↾ (f '' E)` have isomorphic simplifications;
elements with the same nonloop image are parallel. -/
def comapOn (N : Matroid β) (E : Set α) (f : α → β) : Matroid α 
goal: Matroid α

full_name: Matroid.comapOn_preimage_eq
code: lemma comapOn_preimage_eq (N : Matroid β) (f : α → β) : N.comapOn (f ⁻¹' N.E) f = N.comap f 
goal: N.comapOn (f ⁻¹' N.E) f = N.comap f

full_name: Matroid.comapOn_indep_iff
code: @[simp] lemma comapOn_indep_iff :
    (N.comapOn E f).Indep I ↔ (N.Indep (f '' I) ∧ InjOn f I ∧ I ⊆ E) 
goal: (N.comapOn E f).Indep I ↔ N.Indep (f '' I) ∧ Set.InjOn f I ∧ I ⊆ E

full_name: Matroid.comapOn_ground_eq
code: @[simp] lemma comapOn_ground_eq : (N.comapOn E f).E = E 
goal: (N.comapOn E f).E = E

full_name: Matroid.comapOn_base_iff
code: lemma comapOn_base_iff :
    (N.comapOn E f).Base B ↔ N.Basis' (f '' B) (f '' E) ∧ B.InjOn f ∧ B ⊆ E 
goal: (N.comapOn E f).Base B ↔ N.Basis' (f '' B) (f '' E) ∧ Set.InjOn f B ∧ B ⊆ E

full_name: Matroid.comapOn_base_iff_of_surjOn
code: lemma comapOn_base_iff_of_surjOn (h : SurjOn f E N.E) :
    (N.comapOn E f).Base B ↔ (N.Base (f '' B) ∧ InjOn f B ∧ B ⊆ E) 
goal: (N.comapOn E f).Base B ↔ N.Base (f '' B) ∧ Set.InjOn f B ∧ B ⊆ E

full_name: Matroid.comapOn_base_iff_of_bijOn
code: lemma comapOn_base_iff_of_bijOn (h : BijOn f E N.E) :
    (N.comapOn E f).Base B ↔ N.Base (f '' B) ∧ B ⊆ E 
goal: (N.comapOn E f).Base B ↔ N.Base (f '' B) ∧ B ⊆ E

full_name: Matroid.comapOn_dual_eq_of_bijOn
code: lemma comapOn_dual_eq_of_bijOn (h : BijOn f E N.E) :
    (N.comapOn E f)✶ = N✶.comapOn E f 
goal: (N.comapOn E f)✶ = N✶.comapOn E f

full_name: Matroid.comapOn_finitary
code: instance comapOn_finitary [N.Finitary] : (N.comapOn E f).Finitary 
goal: (N.comapOn E f).Finitary

full_name: Matroid.comapOn_finiteRk
code: instance comapOn_finiteRk [N.FiniteRk] : (N.comapOn E f).FiniteRk 
goal: (N.comapOn E f).FiniteRk

full_name: Matroid.mapSetEmbedding
code: /-- Map a matroid `M` to an isomorphic copy in `β` using an embedding `M.E ↪ β`. -/
def mapSetEmbedding (M : Matroid α) (f : M.E ↪ β) : Matroid β 
goal: Matroid β

full_name: Matroid.mapSetEmbedding_ground
code: @[simp] lemma mapSetEmbedding_ground (M : Matroid α) (f : M.E ↪ β) :
    (M.mapSetEmbedding f).E = range f 
goal: (M.mapSetEmbedding f).E = Set.range ⇑f

full_name: Matroid.mapSetEmbedding_indep_iff
code: @[simp] lemma mapSetEmbedding_indep_iff {f : M.E ↪ β} {I : Set β} :
    (M.mapSetEmbedding f).Indep I ↔ M.Indep ↑(f ⁻¹' I) ∧ I ⊆ range f 
goal: (M.mapSetEmbedding f).Indep I ↔ M.Indep ↑(⇑f ⁻¹' I) ∧ I ⊆ Set.range ⇑f

full_name: Matroid.Indep.exists_eq_image_of_mapSetEmbedding
code: lemma Indep.exists_eq_image_of_mapSetEmbedding {f : M.E ↪ β} {I : Set β}
    (hI : (M.mapSetEmbedding f).Indep I) : ∃ (I₀ : Set M.E), M.Indep I₀ ∧ I = f '' I₀ 
goal: ∃ I₀, M.Indep ↑I₀ ∧ I = ⇑f '' I₀

full_name: Matroid.mapSetEmbedding_indep_iff'
code: lemma mapSetEmbedding_indep_iff' {f : M.E ↪ β} {I : Set β} :
    (M.mapSetEmbedding f).Indep I ↔ ∃ (I₀ : Set M.E), M.Indep ↑I₀ ∧ I = f '' I₀ 
goal: (M.mapSetEmbedding f).Indep I ↔ ∃ I₀, M.Indep ↑I₀ ∧ I = ⇑f '' I₀

full_name: Matroid.map
code: /-- Given a function `f` that is injective on `M.E`, the copy of `M` in `β` whose independent sets
are the images of those in `M`. If `β` is a nonempty type, then `N : Matroid β` is a map of `M`
if and only if `M` and `N` are isomorphic. -/
def map (M : Matroid α) (f : α → β) (hf : InjOn f M.E) : Matroid β 
goal: Matroid β

full_name: Matroid.map_ground
code: @[simp] lemma map_ground (M : Matroid α) (f : α → β) (hf) : (M.map f hf).E = f '' M.E 
goal: (M.map f hf).E = f '' M.E

full_name: Matroid.map_indep_iff
code: @[simp] lemma map_indep_iff {hf} {I : Set β} :
    (M.map f hf).Indep I ↔ ∃ I₀, M.Indep I₀ ∧ I = f '' I₀ 
goal: (M.map f hf).Indep I ↔ ∃ I₀, M.Indep I₀ ∧ I = f '' I₀

full_name: Matroid.Indep.map
code: lemma Indep.map (hI : M.Indep I) (f : α → β) (hf) : (M.map f hf).Indep (f '' I) 
goal: (M.map f hf).Indep (f '' I)

full_name: Matroid.Indep.exists_bijOn_of_map
code: lemma Indep.exists_bijOn_of_map {I : Set β} (hf) (hI : (M.map f hf).Indep I) :
    ∃ I₀, M.Indep I₀ ∧ BijOn f I₀ I 
goal: ∃ I₀, M.Indep I₀ ∧ Set.BijOn f I₀ I

full_name: Matroid.map_image_indep_iff
code: lemma map_image_indep_iff {hf} {I : Set α} (hI : I ⊆ M.E) :
    (M.map f hf).Indep (f '' I) ↔ M.Indep I 
goal: (M.map f hf).Indep (f '' I) ↔ M.Indep I

full_name: Matroid.map_base_iff
code: @[simp] lemma map_base_iff (M : Matroid α) (f : α → β) (hf) {B : Set β} :
    (M.map f hf).Base B ↔ ∃ B₀, M.Base B₀ ∧ B = f '' B₀ 
goal: (M.map f hf).Base B ↔ ∃ B₀, M.Base B₀ ∧ B = f '' B₀

full_name: Matroid.Base.map
code: lemma Base.map {B : Set α} (hB : M.Base B) {f : α → β} (hf) : (M.map f hf).Base (f '' B) 
goal: (M.map f hf).Base (f '' B)

full_name: Matroid.map_dep_iff
code: lemma map_dep_iff {hf} {D : Set β} :
    (M.map f hf).Dep D ↔ ∃ D₀, M.Dep D₀ ∧ D = f '' D₀ 
goal: (M.map f hf).Dep D ↔ ∃ D₀, M.Dep D₀ ∧ D = f '' D₀

full_name: Matroid.map_image_base_iff
code: lemma map_image_base_iff {hf} {B : Set α} (hB : B ⊆ M.E) :
    (M.map f hf).Base (f '' B) ↔ M.Base B 
goal: (M.map f hf).Base (f '' B) ↔ M.Base B

full_name: Matroid.Basis.map
code: lemma Basis.map {X : Set α} (hIX : M.Basis I X) {f : α → β} (hf) :
    (M.map f hf).Basis (f '' I) (f '' X) 
goal: (M.map f hf).Basis (f '' I) (f '' X)

full_name: Matroid.map_basis_iff
code: lemma map_basis_iff {I X : Set α} (f : α → β) (hf) (hI : I ⊆ M.E) (hX : X ⊆ M.E) :
    (M.map f hf).Basis (f '' I) (f '' X) ↔ M.Basis I X 
goal: (M.map f hf).Basis (f '' I) (f '' X) ↔ M.Basis I X

full_name: Matroid.map_basis_iff'
code: lemma map_basis_iff' {I X : Set β} {hf} :
    (M.map f hf).Basis I X ↔ ∃ I₀ X₀, M.Basis I₀ X₀ ∧ I = f '' I₀ ∧ X = f '' X₀ 
goal: (M.map f hf).Basis I X ↔ ∃ I₀ X₀, M.Basis I₀ X₀ ∧ I = f '' I₀ ∧ X = f '' X₀

full_name: Matroid.map_dual
code: @[simp] lemma map_dual {hf} : (M.map f hf)✶ = M✶.map f hf 
goal: (M.map f hf)✶ = M✶.map f hf

full_name: Matroid.map_emptyOn
code: @[simp] lemma map_emptyOn (f : α → β) : (emptyOn α).map f (by simp) = emptyOn β 
goal: (Matroid.emptyOn α).map f ⋯ = Matroid.emptyOn β

full_name: Matroid.map_loopyOn
code: @[simp] lemma map_loopyOn (f : α → β) (hf) : (loopyOn E).map f hf = loopyOn (f '' E) 
goal: (Matroid.loopyOn E).map f hf = Matroid.loopyOn (f '' E)

full_name: Matroid.map_freeOn
code: @[simp] lemma map_freeOn (f : α → β) (hf) : (freeOn E).map f hf = freeOn (f '' E) 
goal: (Matroid.freeOn E).map f hf = Matroid.freeOn (f '' E)

full_name: Matroid.map_id
code: @[simp] lemma map_id : M.map id (injOn_id M.E) = M 
goal: M.map id ⋯ = M

full_name: Matroid.map_comap
code: lemma map_comap {f : α → β} (h_range : N.E ⊆ range f) (hf : InjOn f (f ⁻¹' N.E)) :
    (N.comap f).map f hf = N 
goal: (N.comap f).map f hf = N

full_name: Matroid.comap_map
code: lemma comap_map {f : α → β} (hf : f.Injective) : (M.map f hf.injOn).comap f = M 
goal: (M.map f ⋯).comap f = M

full_name: Matroid.instNonemptyMap
code: instance [M.Nonempty] {f : α → β} (hf) : (M.map f hf).Nonempty 
goal: (M.map f hf).Nonempty

full_name: Matroid.instFiniteMap
code: instance [M.Finite] {f : α → β} (hf) : (M.map f hf).Finite 
goal: (M.map f hf).Finite

full_name: Matroid.instFinitaryMap
code: instance [M.Finitary] {f : α → β} (hf) : (M.map f hf).Finitary 
goal: (M.map f hf).Finitary

full_name: Matroid.instFiniteRkMap
code: instance [M.FiniteRk] {f : α → β} (hf) : (M.map f hf).FiniteRk 
goal: (M.map f hf).FiniteRk

full_name: Matroid.instRkPosMap
code: instance [M.RkPos] {f : α → β} (hf) : (M.map f hf).RkPos 
goal: (M.map f hf).RkPos

full_name: Matroid.mapSetEquiv
code: /-- Map `M : Matroid α` to a `Matroid β` with ground set `E` using an equivalence `M.E ≃ E`.
Defined using `Matroid.ofExistsMatroid` for better defeq.  -/
def mapSetEquiv (M : Matroid α) {E : Set β} (e : M.E ≃ E) : Matroid β 
goal: Matroid β

full_name: Matroid.mapSetEquiv_indep_iff
code: @[simp] lemma mapSetEquiv_indep_iff (M : Matroid α) {E : Set β} (e : M.E ≃ E) {I : Set β} :
    (M.mapSetEquiv e).Indep I ↔ M.Indep ↑(e.symm '' (E ↓∩ I)) ∧ I ⊆ E 
goal: (M.mapSetEquiv e).Indep I ↔ M.Indep ↑(⇑e.symm '' E ↓∩ I) ∧ I ⊆ E

full_name: Matroid.mapSetEquiv.ground
code: @[simp] lemma mapSetEquiv.ground (M : Matroid α) {E : Set β} (e : M.E ≃ E) :
    (M.mapSetEquiv e).E = E 
goal: (M.mapSetEquiv e).E = E

full_name: Matroid.mapEmbedding
code: /-- Map `M : Matroid α` across an embedding defined on all of `α` -/
def mapEmbedding (M : Matroid α) (f : α ↪ β) : Matroid β 
goal: Matroid β

full_name: Matroid.mapEmbedding_ground_eq
code: @[simp] lemma mapEmbedding_ground_eq (M : Matroid α) (f : α ↪ β) :
    (M.mapEmbedding f).E = f '' M.E 
goal: (M.mapEmbedding f).E = ⇑f '' M.E

full_name: Matroid.mapEmbedding_indep_iff
code: @[simp] lemma mapEmbedding_indep_iff {f : α ↪ β} {I : Set β} :
    (M.mapEmbedding f).Indep I ↔ M.Indep (f ⁻¹' I) ∧ I ⊆ range f 
goal: (M.mapEmbedding f).Indep I ↔ M.Indep (⇑f ⁻¹' I) ∧ I ⊆ Set.range ⇑f

full_name: Matroid.Indep.mapEmbedding
code: lemma Indep.mapEmbedding (hI : M.Indep I) (f : α ↪ β) : (M.mapEmbedding f).Indep (f '' I) 
goal: (M.mapEmbedding f).Indep (⇑f '' I)

full_name: Matroid.Base.mapEmbedding
code: lemma Base.mapEmbedding {B : Set α} (hB : M.Base B) (f : α ↪ β) :
    (M.mapEmbedding f).Base (f '' B) 
goal: (M.mapEmbedding f).Base (⇑f '' B)

full_name: Matroid.Basis.mapEmbedding
code: lemma Basis.mapEmbedding {X : Set α} (hIX : M.Basis I X) (f : α ↪ β) :
    (M.mapEmbedding f).Basis (f '' I) (f '' X) 
goal: (M.mapEmbedding f).Basis (⇑f '' I) (⇑f '' X)

full_name: Matroid.mapEmbedding_base_iff
code: @[simp] lemma mapEmbedding_base_iff {f : α ↪ β} {B : Set β} :
    (M.mapEmbedding f).Base B ↔ M.Base (f ⁻¹' B) ∧ B ⊆ range f 
goal: (M.mapEmbedding f).Base B ↔ M.Base (⇑f ⁻¹' B) ∧ B ⊆ Set.range ⇑f

full_name: Matroid.mapEmbedding_basis_iff
code: @[simp] lemma mapEmbedding_basis_iff {f : α ↪ β} {I X : Set β} :
    (M.mapEmbedding f).Basis I X ↔ M.Basis (f ⁻¹' I) (f ⁻¹' X) ∧ I ⊆ X ∧ X ⊆ range f 
goal: (M.mapEmbedding f).Basis I X ↔ M.Basis (⇑f ⁻¹' I) (⇑f ⁻¹' X) ∧ I ⊆ X ∧ X ⊆ Set.range ⇑f

full_name: Matroid.instNonemptyMapEmbedding
code: instance [M.Nonempty] {f : α ↪ β} : (M.mapEmbedding f).Nonempty 
goal: (M.mapEmbedding f).Nonempty

full_name: Matroid.instFiniteMapEmbedding
code: instance [M.Finite] {f : α ↪ β} : (M.mapEmbedding f).Finite 
goal: (M.mapEmbedding f).Finite

full_name: Matroid.instFinitaryMapEmbedding
code: instance [M.Finitary] {f : α ↪ β} : (M.mapEmbedding f).Finitary 
goal: (M.mapEmbedding f).Finitary

full_name: Matroid.instFiniteRkMapEmbedding
code: instance [M.FiniteRk] {f : α ↪ β} : (M.mapEmbedding f).FiniteRk 
goal: (M.mapEmbedding f).FiniteRk

full_name: Matroid.instRkPosMapEmbedding
code: instance [M.RkPos] {f : α ↪ β} : (M.mapEmbedding f).RkPos 
goal: (M.mapEmbedding f).RkPos

full_name: Matroid.mapEquiv
code: /-- Map `M : Matroid α` across an equivalence `α ≃ β` -/
def mapEquiv (M : Matroid α) (f : α ≃ β) : Matroid β 
goal: Matroid β

full_name: Matroid.mapEquiv_ground_eq
code: @[simp] lemma mapEquiv_ground_eq (M : Matroid α) (f : α ≃ β) :
    (M.mapEquiv f).E = f '' M.E 
goal: (M.mapEquiv f).E = ⇑f '' M.E

full_name: Matroid.mapEquiv_eq_map
code: lemma mapEquiv_eq_map (f : α ≃ β) : M.mapEquiv f = M.map f f.injective.injOn 
goal: M.mapEquiv f = M.map ⇑f ⋯

full_name: Matroid.mapEquiv_indep_iff
code: @[simp] lemma mapEquiv_indep_iff {I : Set β} : (M.mapEquiv f).Indep I ↔ M.Indep (f.symm '' I) 
goal: (M.mapEquiv f).Indep I ↔ M.Indep (⇑f.symm '' I)

full_name: Matroid.mapEquiv_dep_iff
code: @[simp] lemma mapEquiv_dep_iff {D : Set β} : (M.mapEquiv f).Dep D ↔ M.Dep (f.symm '' D) 
goal: (M.mapEquiv f).Dep D ↔ M.Dep (⇑f.symm '' D)

full_name: Matroid.mapEquiv_base_iff
code: @[simp] lemma mapEquiv_base_iff {B : Set β} : (M.mapEquiv f).Base B ↔ M.Base (f.symm '' B) 
goal: (M.mapEquiv f).Base B ↔ M.Base (⇑f.symm '' B)

full_name: Matroid.mapEquiv_basis_iff
code: @[simp] lemma mapEquiv_basis_iff {α β : Type*} {M : Matroid α} (f : α ≃ β) {I X : Set β} :
    (M.mapEquiv f).Basis I X ↔ M.Basis (f.symm '' I) (f.symm '' X) 
goal: (M.mapEquiv f).Basis I X ↔ M.Basis (⇑f.symm '' I) (⇑f.symm '' X)

full_name: Matroid.instNonemptyMapEquiv
code: instance [M.Nonempty] {f : α ≃ β} : (M.mapEquiv f).Nonempty 
goal: (M.mapEquiv f).Nonempty

full_name: Matroid.instFiniteMapEquiv
code: instance [M.Finite] {f : α ≃ β} : (M.mapEquiv f).Finite 
goal: (M.mapEquiv f).Finite

full_name: Matroid.instFinitaryMapEquiv
code: instance [M.Finitary] {f : α ≃ β} : (M.mapEquiv f).Finitary 
goal: (M.mapEquiv f).Finitary

full_name: Matroid.instFiniteRkMapEquiv
code: instance [M.FiniteRk] {f : α ≃ β} : (M.mapEquiv f).FiniteRk 
goal: (M.mapEquiv f).FiniteRk

full_name: Matroid.instRkPosMapEquiv
code: instance [M.RkPos] {f : α ≃ β} : (M.mapEquiv f).RkPos 
goal: (M.mapEquiv f).RkPos

full_name: Matroid.restrictSubtype
code: /-- Given `M : Matroid α` and `X : Set α`, the restriction of `M` to `X`,
viewed as a matroid on type `X` with ground set `univ`.
Always isomorphic to `M ↾ X`. If `X = M.E`, then isomorphic to `M`. -/
def restrictSubtype (M : Matroid α) (X : Set α) : Matroid X 
goal: Matroid ↑X

full_name: Matroid.restrictSubtype_ground
code: @[simp] lemma restrictSubtype_ground : (M.restrictSubtype X).E = univ 
goal: (M.restrictSubtype X).E = Set.univ

full_name: Matroid.restrictSubtype_indep_iff
code: @[simp] lemma restrictSubtype_indep_iff {I : Set X} :
    (M.restrictSubtype X).Indep I ↔ M.Indep ((↑) '' I) 
goal: (M.restrictSubtype X).Indep I ↔ M.Indep ↑I

full_name: Matroid.restrictSubtype_indep_iff_of_subset
code: lemma restrictSubtype_indep_iff_of_subset (hIX : I ⊆ X) :
    (M.restrictSubtype X).Indep (X ↓∩ I) ↔ M.Indep I 
goal: (M.restrictSubtype X).Indep (X ↓∩ I) ↔ M.Indep I

full_name: Matroid.restrictSubtype_inter_indep_iff
code: lemma restrictSubtype_inter_indep_iff :
    (M.restrictSubtype X).Indep (X ↓∩ I) ↔ M.Indep (X ∩ I) 
goal: (M.restrictSubtype X).Indep (X ↓∩ I) ↔ M.Indep (X ∩ I)

full_name: Matroid.restrictSubtype_basis_iff
code: lemma restrictSubtype_basis_iff {Y : Set α} {I X : Set Y} :
    (M.restrictSubtype Y).Basis I X ↔ M.Basis' I X 
goal: (M.restrictSubtype Y).Basis I X ↔ M.Basis' ↑I ↑X

full_name: Matroid.restrictSubtype_base_iff
code: lemma restrictSubtype_base_iff {B : Set X} : (M.restrictSubtype X).Base B ↔ M.Basis' B X 
goal: (M.restrictSubtype X).Base B ↔ M.Basis' (↑B) X

full_name: Matroid.restrictSubtype_ground_base_iff
code: @[simp] lemma restrictSubtype_ground_base_iff {B : Set M.E} :
    (M.restrictSubtype M.E).Base B ↔ M.Base B 
goal: (M.restrictSubtype M.E).Base B ↔ M.Base ↑B

full_name: Matroid.restrictSubtype_ground_basis_iff
code: @[simp] lemma restrictSubtype_ground_basis_iff {I X : Set M.E} :
    (M.restrictSubtype M.E).Basis I X ↔ M.Basis I X 
goal: (M.restrictSubtype M.E).Basis I X ↔ M.Basis ↑I ↑X

full_name: Matroid.eq_of_restrictSubtype_eq
code: lemma eq_of_restrictSubtype_eq {N : Matroid α} (hM : M.E = E) (hN : N.E = E)
    (h : M.restrictSubtype E = N.restrictSubtype E) : M = N 
goal: M = N

full_name: Matroid.restrictSubtype_dual
code: @[simp] lemma restrictSubtype_dual : (M.restrictSubtype M.E)✶ = M✶.restrictSubtype M.E 
goal: (M.restrictSubtype M.E)✶ = M✶.restrictSubtype M.E

full_name: Matroid.restrictSubtype_dual'
code: lemma restrictSubtype_dual' (hM : M.E = E) : (M.restrictSubtype E)✶ = M✶.restrictSubtype E 
goal: (M.restrictSubtype E)✶ = M✶.restrictSubtype E

full_name: Matroid.map_val_restrictSubtype_eq
code: /-- `M.restrictSubtype X` is isomorphic to `M ↾ X`. -/
@[simp] lemma map_val_restrictSubtype_eq (M : Matroid α) (X : Set α) :
    (M.restrictSubtype X).map (↑) Subtype.val_injective.injOn = M ↾ X 
goal: (M.restrictSubtype X).map Subtype.val ⋯ = M.restrict X

full_name: Matroid.map_val_restrictSubtype_ground_eq
code: /-- `M.restrictSubtype M.E` is isomorphic to `M`. -/
lemma map_val_restrictSubtype_ground_eq (M : Matroid α) :
    (M.restrictSubtype M.E).map (↑) Subtype.val_injective.injOn = M 
goal: (M.restrictSubtype M.E).map Subtype.val ⋯ = M

full_name: Matroid.instFinitaryElemRestrictSubtype
code: instance [M.Finitary] {X : Set α} : (M.restrictSubtype X).Finitary 
goal: (M.restrictSubtype X).Finitary

full_name: Matroid.instFiniteRkElemRestrictSubtype
code: instance [M.FiniteRk] {X : Set α} : (M.restrictSubtype X).FiniteRk 
goal: (M.restrictSubtype X).FiniteRk

full_name: Matroid.instFiniteElemERestrictSubtype
code: instance [M.Finite] : (M.restrictSubtype M.E).Finite 
goal: (M.restrictSubtype M.E).Finite

full_name: Matroid.instNonemptyElemERestrictSubtype
code: instance [M.Nonempty] : (M.restrictSubtype M.E).Nonempty 
goal: (M.restrictSubtype M.E).Nonempty

full_name: Matroid.instRkPosElemERestrictSubtype
code: instance [M.RkPos] : (M.restrictSubtype M.E).RkPos 
goal: (M.restrictSubtype M.E).RkPos