ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/AlgebraicTopology/KanComplex.lean

full_name: SSet.KanComplex
code: /-- A simplicial set `S` is a *Kan complex* if it satisfies the following horn-filling condition:
for every `n : ℕ` and `0 ≤ i ≤ n`,
every map of simplicial sets `σ₀ : Λ[n, i] → S` can be extended to a map `σ : Δ[n] → S`. -/
class KanComplex (S : SSet) : Prop where
  hornFilling : ∀ ⦃n : ℕ⦄ ⦃i : Fin (n+1)⦄ (σ₀ : Λ[n, i] ⟶ S),
    ∃ σ : Δ[n] ⟶ S, σ₀ = hornInclusion n i ≫ σ
goal: Prop

full_name: SSet.KanComplex.hornFilling
code: /-- A simplicial set `S` is a *Kan complex* if it satisfies the following horn-filling condition:
for every `n : ℕ` and `0 ≤ i ≤ n`,
every map of simplicial sets `σ₀ : Λ[n, i] → S` can be extended to a map `σ : Δ[n] → S`. -/
class KanComplex (S : SSet) : Prop where
  hornFilling : ∀ ⦃n : ℕ⦄ ⦃i : Fin (n+1)⦄ (σ₀ : Λ[n, i] ⟶ S),
    ∃ σ : Δ[n] ⟶ S, σ₀ = hornInclusion n i ≫ σ
goal: ∃ σ, σ₀ = CategoryTheory.CategoryStruct.comp (SSet.hornInclusion n i) σ
File: Mathlib/SetTheory/ZFC/Ordinal.lean

full_name: ZFSet.IsTransitive
code: /-- A transitive set is one where every element is a subset. -/
def IsTransitive (x : ZFSet) : Prop 
goal: Prop

full_name: ZFSet.empty_isTransitive
code: @[simp]
theorem empty_isTransitive : IsTransitive ∅ 
goal: ∅.IsTransitive

full_name: ZFSet.IsTransitive.subset_of_mem
code: theorem IsTransitive.subset_of_mem (h : x.IsTransitive) : y ∈ x → y ⊆ x 
goal: y ∈ x → y ⊆ x

full_name: ZFSet.isTransitive_iff_mem_trans
code: theorem isTransitive_iff_mem_trans : z.IsTransitive ↔ ∀ {x y : ZFSet}, x ∈ y → y ∈ z → x ∈ z 
goal: z.IsTransitive ↔ ∀ {x y : ZFSet}, x ∈ y → y ∈ z → x ∈ z

full_name: ZFSet.IsTransitive.inter
code: protected theorem IsTransitive.inter (hx : x.IsTransitive) (hy : y.IsTransitive) :
    (x ∩ y).IsTransitive 
goal: (x ∩ y).IsTransitive

full_name: ZFSet.IsTransitive.sUnion
code: protected theorem IsTransitive.sUnion (h : x.IsTransitive) :
    (⋃₀ x : ZFSet).IsTransitive 
goal: (⋃₀ x).IsTransitive

full_name: ZFSet.IsTransitive.sUnion'
code: theorem IsTransitive.sUnion' (H : ∀ y ∈ x, IsTransitive y) :
    (⋃₀ x : ZFSet).IsTransitive 
goal: (⋃₀ x).IsTransitive

full_name: ZFSet.IsTransitive.union
code: protected theorem IsTransitive.union (hx : x.IsTransitive) (hy : y.IsTransitive) :
    (x ∪ y).IsTransitive 
goal: (x ∪ y).IsTransitive

full_name: ZFSet.IsTransitive.powerset
code: protected theorem IsTransitive.powerset (h : x.IsTransitive) : (powerset x).IsTransitive 
goal: x.powerset.IsTransitive

full_name: ZFSet.isTransitive_iff_sUnion_subset
code: theorem isTransitive_iff_sUnion_subset : x.IsTransitive ↔ (⋃₀ x : ZFSet) ⊆ x 
goal: x.IsTransitive ↔ ⋃₀ x ⊆ x

full_name: ZFSet.isTransitive_iff_subset_powerset
code: theorem isTransitive_iff_subset_powerset : x.IsTransitive ↔ x ⊆ powerset x 
goal: x.IsTransitive ↔ x ⊆ x.powerset
File: Mathlib/AlgebraicTopology/Nerve.lean

full_name: CategoryTheory.nerve
code: /-- The nerve of a category -/
@[simps]
def nerve (C : Type u) [Category.{v} C] : SSet.{max u v} 
goal: SSet

full_name: CategoryTheory.nerve_map
code: /-- The nerve of a category -/
@[simps]
def nerve (C : Type u) [Category.{v} C] : SSet.{max u v} 
goal: ∀ {X Y : SimplexCategoryᵒᵖ} (f : X ⟶ Y) (x : CategoryTheory.ComposableArrows C (Opposite.unop X).len),
  (CategoryTheory.nerve C).map f x = x.whiskerLeft (SimplexCategory.toCat.map f.unop)

full_name: CategoryTheory.nerve_obj
code: /-- The nerve of a category -/
@[simps]
def nerve (C : Type u) [Category.{v} C] : SSet.{max u v} 
goal: (CategoryTheory.nerve C).obj Δ = CategoryTheory.ComposableArrows C (Opposite.unop Δ).len

full_name: CategoryTheory.instCategoryObjOppositeSimplexCategoryNerve
code: instance {C : Type*} [Category C] {Δ : SimplexCategoryᵒᵖ} : Category ((nerve C).obj Δ) 
goal: CategoryTheory.Category.{u_2, max u_1 u_2} ((CategoryTheory.nerve C).obj Δ)

full_name: CategoryTheory.nerveFunctor_map_app
code: /-- The nerve of a category, as a functor `Cat ⥤ SSet` -/
@[simps]
def nerveFunctor : Cat ⥤ SSet 
goal: ∀ {X Y : CategoryTheory.Cat} (F : X ⟶ Y) (Δ : SimplexCategoryᵒᵖ)
  (a : CategoryTheory.ComposableArrows (↑X) (Opposite.unop Δ).len),
  (CategoryTheory.nerveFunctor.map F).app Δ a =
    (CategoryTheory.Functor.mapComposableArrows F (Opposite.unop Δ).len).obj a

full_name: CategoryTheory.nerveFunctor
code: /-- The nerve of a category, as a functor `Cat ⥤ SSet` -/
@[simps]
def nerveFunctor : Cat ⥤ SSet 
goal: CategoryTheory.Functor CategoryTheory.Cat SSet

full_name: CategoryTheory.nerveFunctor_obj
code: /-- The nerve of a category, as a functor `Cat ⥤ SSet` -/
@[simps]
def nerveFunctor : Cat ⥤ SSet 
goal: CategoryTheory.nerveFunctor.obj C = CategoryTheory.nerve ↑C

full_name: CategoryTheory.Nerve.δ₀_eq
code: lemma δ₀_eq {x : nerve C _[n + 1]} : (nerve C).δ (0 : Fin (n + 2)) x = x.δ₀ 
goal: CategoryTheory.SimplicialObject.δ (CategoryTheory.nerve C) 0 x = CategoryTheory.ComposableArrows.δ₀ x
File: Mathlib/AlgebraicTopology/DoldKan/Degeneracies.lean

full_name: AlgebraicTopology.DoldKan.HigherFacesVanish.comp_σ
code: theorem HigherFacesVanish.comp_σ {Y : C} {X : SimplicialObject C} {n b q : ℕ} {φ : Y ⟶ X _[n + 1]}
    (v : HigherFacesVanish q φ) (hnbq : n + 1 = b + q) :
    HigherFacesVanish q
      (φ ≫
        X.σ ⟨b, by
          simp only [hnbq, Nat.lt_add_one_iff, le_add_iff_nonneg_right, zero_le]⟩) 
goal: AlgebraicTopology.DoldKan.HigherFacesVanish q (φ ≫ X.σ ⟨b, ⋯⟩)

full_name: AlgebraicTopology.DoldKan.σ_comp_P_eq_zero
code: theorem σ_comp_P_eq_zero (X : SimplicialObject C) {n q : ℕ} (i : Fin (n + 1)) (hi : n + 1 ≤ i + q) :
    X.σ i ≫ (P q).f (n + 1) = 0 
goal: X.σ i ≫ (AlgebraicTopology.DoldKan.P q).f (n + 1) = 0

full_name: AlgebraicTopology.DoldKan.σ_comp_PInfty
code: @[reassoc (attr := simp)]
theorem σ_comp_PInfty (X : SimplicialObject C) {n : ℕ} (i : Fin (n + 1)) :
    X.σ i ≫ PInfty.f (n + 1) = 0 
goal: X.σ i ≫ AlgebraicTopology.DoldKan.PInfty.f (n + 1) = 0

full_name: AlgebraicTopology.DoldKan.degeneracy_comp_PInfty
code: @[reassoc]
theorem degeneracy_comp_PInfty (X : SimplicialObject C) (n : ℕ) {Δ' : SimplexCategory}
    (θ : ([n] : SimplexCategory) ⟶ Δ') (hθ : ¬Mono θ) : X.map θ.op ≫ PInfty.f n = 0 
goal: X.map θ.op ≫ AlgebraicTopology.DoldKan.PInfty.f n = 0
File: Mathlib/SetTheory/Cardinal/UnivLE.lean

full_name: univLE_iff_cardinal_le
code: theorem univLE_iff_cardinal_le : UnivLE.{u, v} ↔ univ.{u, v+1} ≤ univ.{v, u+1} 
goal: UnivLE.{u, v} ↔ Cardinal.univ.{u, v + 1} ≤ Cardinal.univ.{v, u + 1}

full_name: univLE_total
code: /-- Together with transitivity, this shows UnivLE "IsTotalPreorder". -/
theorem univLE_total : UnivLE.{u, v} ∨ UnivLE.{v, u} 
goal: UnivLE.{u, v} ∨ UnivLE.{v, u}
File: Mathlib/SetTheory/Cardinal/Subfield.lean

full_name: _private.Mathlib.SetTheory.Cardinal.Subfield.0.Subfield.Operands
code: private abbrev Operands : Fin 6 ⊕ s → Type
  
goal: Fin 6 ⊕ ↑s → Type

full_name: _private.Mathlib.SetTheory.Cardinal.Subfield.0.Subfield.operate
code: private def operate : (Σ n, Operands s n → closure s) → closure s
  
goal: (n : Fin 6 ⊕ ↑s) × (Subfield.Operands s n → ↥(Subfield.closure s)) → ↥(Subfield.closure s)

full_name: _private.Mathlib.SetTheory.Cardinal.Subfield.0.Subfield.rangeOfWType
code: private def rangeOfWType : Subfield (closure s) 
goal: Subfield ↥(Subfield.closure s)

full_name: _private.Mathlib.SetTheory.Cardinal.Subfield.0.Subfield.rangeOfWType_eq_top
code: private lemma rangeOfWType_eq_top : rangeOfWType s = ⊤ 
goal: Subfield.rangeOfWType s = ⊤

full_name: _private.Mathlib.SetTheory.Cardinal.Subfield.0.Subfield.surjective_ofWType
code: private lemma surjective_ofWType : Function.Surjective (WType.elim _ <| operate s) 
goal: Function.Surjective (WType.elim (↥(Subfield.closure s)) (Subfield.operate s))

full_name: Subfield.cardinal_mk_closure_le_max
code: lemma cardinal_mk_closure_le_max : #(closure s) ≤ max #s ℵ₀ 
goal: Cardinal.mk ↥(Subfield.closure s) ≤ max (Cardinal.mk ↑s) Cardinal.aleph0

full_name: Subfield.cardinal_mk_closure
code: lemma cardinal_mk_closure [Infinite s] : #(closure s) = #s 
goal: Cardinal.mk ↥(Subfield.closure s) = Cardinal.mk ↑s
File: Mathlib/AlgebraicTopology/DoldKan/NReflectsIso.lean

full_name: AlgebraicTopology.DoldKan.instReflectsIsomorphismsSimplicialObjectKaroubiChainComplexNatN₁
code: instance : (N₁ : SimplicialObject C ⥤ Karoubi (ChainComplex C ℕ)).ReflectsIsomorphisms 
goal: AlgebraicTopology.DoldKan.N₁.ReflectsIsomorphisms

full_name: AlgebraicTopology.DoldKan.compatibility_N₂_N₁_karoubi
code: theorem compatibility_N₂_N₁_karoubi :
    N₂ ⋙ (karoubiChainComplexEquivalence C ℕ).functor =
      karoubiFunctorCategoryEmbedding SimplexCategoryᵒᵖ C ⋙
        N₁ ⋙ (karoubiChainComplexEquivalence (Karoubi C) ℕ).functor ⋙
            Functor.mapHomologicalComplex (KaroubiKaroubi.equivalence C).inverse _ 
goal: AlgebraicTopology.DoldKan.N₂ ⋙ (CategoryTheory.Idempotents.karoubiChainComplexEquivalence C ℕ).functor =
  CategoryTheory.Idempotents.karoubiFunctorCategoryEmbedding SimplexCategoryᵒᵖ C ⋙
    AlgebraicTopology.DoldKan.N₁ ⋙
      (CategoryTheory.Idempotents.karoubiChainComplexEquivalence (CategoryTheory.Idempotents.Karoubi C) ℕ).functor ⋙
        (CategoryTheory.Idempotents.KaroubiKaroubi.equivalence C).inverse.mapHomologicalComplex (ComplexShape.down ℕ)

full_name: AlgebraicTopology.DoldKan.instReflectsIsomorphismsKaroubiSimplicialObjectChainComplexNatN₂
code: /-- We deduce that `N₂ : Karoubi (SimplicialObject C) ⥤ Karoubi (ChainComplex C ℕ))`
reflects isomorphisms from the fact that
`N₁ : SimplicialObject (Karoubi C) ⥤ Karoubi (ChainComplex (Karoubi C) ℕ)` does. -/
instance : (N₂ : Karoubi (SimplicialObject C) ⥤ Karoubi (ChainComplex C ℕ)).ReflectsIsomorphisms 
goal: AlgebraicTopology.DoldKan.N₂.ReflectsIsomorphisms
File: Mathlib/SetTheory/Cardinal/CountableCover.lean

full_name: Cardinal.mk_subtype_le_of_countable_eventually_mem_aux
code: /-- If a set `t` is eventually covered by a countable family of sets, all with cardinality at
most `a`, then the cardinality of `t` is also bounded by `a`.
Supersed by `mk_le_of_countable_eventually_mem` which does not assume
that the indexing set lives in the same universe. -/
lemma mk_subtype_le_of_countable_eventually_mem_aux {α ι : Type u} {a : Cardinal}
    [Countable ι] {f : ι → Set α} {l : Filter ι} [NeBot l]
    {t : Set α} (ht : ∀ x ∈ t, ∀ᶠ i in l, x ∈ f i)
    (h'f : ∀ i, #(f i) ≤ a) : #t ≤ a 
goal: #↑t ≤ a

full_name: Cardinal.mk_subtype_le_of_countable_eventually_mem
code: /-- If a set `t` is eventually covered by a countable family of sets, all with cardinality at
most `a`, then the cardinality of `t` is also bounded by `a`. -/
lemma mk_subtype_le_of_countable_eventually_mem {α : Type u} {ι : Type v} {a : Cardinal}
    [Countable ι] {f : ι → Set α} {l : Filter ι} [NeBot l]
    {t : Set α} (ht : ∀ x ∈ t, ∀ᶠ i in l, x ∈ f i)
    (h'f : ∀ i, #(f i) ≤ a) : #t ≤ a 
goal: #↑t ≤ a

full_name: Cardinal.mk_le_of_countable_eventually_mem
code: /-- If a space is eventually covered by a countable family of sets, all with cardinality at
most `a`, then the cardinality of the space is also bounded by `a`. -/
lemma mk_le_of_countable_eventually_mem {α : Type u} {ι : Type v} {a : Cardinal}
    [Countable ι] {f : ι → Set α} {l : Filter ι} [NeBot l] (ht : ∀ x, ∀ᶠ i in l, x ∈ f i)
    (h'f : ∀ i, #(f i) ≤ a) : #α ≤ a 
goal: #α ≤ a

full_name: Cardinal.mk_of_countable_eventually_mem
code: /-- If a space is eventually covered by a countable family of sets, all with cardinality `a`,
then the cardinality of the space is also `a`. -/
lemma mk_of_countable_eventually_mem {α : Type u} {ι : Type v} {a : Cardinal}
    [Countable ι] {f : ι → Set α} {l : Filter ι} [NeBot l] (ht : ∀ x, ∀ᶠ i in l, x ∈ f i)
    (h'f : ∀ i, #(f i) = a) : #α = a 
goal: #α = a
File: Mathlib/SetTheory/Cardinal/SchroederBernstein.lean

full_name: Function.Embedding.schroeder_bernstein
code: /-- **The Schröder-Bernstein Theorem**:
Given injections `α → β` and `β → α`, we can get a bijection `α → β`. -/
theorem schroeder_bernstein {f : α → β} {g : β → α} (hf : Function.Injective f)
    (hg : Function.Injective g) : ∃ h : α → β, Bijective h 
goal: ∃ h, Function.Bijective h

full_name: Function.Embedding.antisymm
code: /-- **The Schröder-Bernstein Theorem**: Given embeddings `α ↪ β` and `β ↪ α`, there exists an
equivalence `α ≃ β`. -/
theorem antisymm : (α ↪ β) → (β ↪ α) → Nonempty (α ≃ β)
  
goal: (α ↪ β) → (β ↪ α) → Nonempty (α ≃ β)

full_name: _private.Mathlib.SetTheory.Cardinal.SchroederBernstein.0.Function.Embedding.sets
code: /-- `sets β` -/
private abbrev sets 
goal: Set (Set ((i : ι) → β i))

full_name: Function.Embedding.min_injective
code: /-- The cardinals are well-ordered. We express it here by the fact that in any set of cardinals
there is an element that injects into the others.
See `Cardinal.conditionallyCompleteLinearOrderBot` for (one of) the lattice instances. -/
theorem min_injective [I : Nonempty ι] : ∃ i, Nonempty (∀ j, β i ↪ β j) 
goal: ∃ i, Nonempty ((j : ι) → β i ↪ β j)

full_name: Function.Embedding.total
code: /-- The cardinals are totally ordered. See
`Cardinal.conditionallyCompleteLinearOrderBot` for (one of) the lattice
instance. -/
-- Porting note: `ULift.{max u v, u} α` was `ULift α`
theorem total (α : Type u) (β : Type v) : Nonempty (α ↪ β) ∨ Nonempty (β ↪ α) 
goal: Nonempty (α ↪ β) ∨ Nonempty (β ↪ α)
File: Mathlib/AlgebraicTopology/DoldKan/Faces.lean

full_name: AlgebraicTopology.DoldKan.HigherFacesVanish
code: /-- A morphism `φ : Y ⟶ X _[n+1]` satisfies `HigherFacesVanish q φ`
when the compositions `φ ≫ X.δ j` are `0` for `j ≥ max 1 (n+2-q)`. When `q ≤ n+1`,
it basically means that the composition `φ ≫ X.δ j` are `0` for the `q` highest
possible values of a nonzero `j`. Otherwise, when `q ≥ n+2`, all the compositions
`φ ≫ X.δ j` for nonzero `j` vanish. See also the lemma `comp_P_eq_self_iff` in
`Projections.lean` which states that `HigherFacesVanish q φ` is equivalent to
the identity `φ ≫ (P q).f (n+1) = φ`. -/
def HigherFacesVanish {Y : C} {n : ℕ} (q : ℕ) (φ : Y ⟶ X _[n + 1]) : Prop 
goal: Prop

full_name: AlgebraicTopology.DoldKan.HigherFacesVanish.comp_δ_eq_zero
code: @[reassoc]
theorem comp_δ_eq_zero {Y : C} {n : ℕ} {q : ℕ} {φ : Y ⟶ X _[n + 1]} (v : HigherFacesVanish q φ)
    (j : Fin (n + 2)) (hj₁ : j ≠ 0) (hj₂ : n + 2 ≤ (j : ℕ) + q) : φ ≫ X.δ j = 0 
goal: φ ≫ X.δ j = 0

full_name: AlgebraicTopology.DoldKan.HigherFacesVanish.of_succ
code: theorem of_succ {Y : C} {n q : ℕ} {φ : Y ⟶ X _[n + 1]} (v : HigherFacesVanish (q + 1) φ) :
    HigherFacesVanish q φ 
goal: AlgebraicTopology.DoldKan.HigherFacesVanish q φ

full_name: AlgebraicTopology.DoldKan.HigherFacesVanish.of_comp
code: theorem of_comp {Y Z : C} {q n : ℕ} {φ : Y ⟶ X _[n + 1]} (v : HigherFacesVanish q φ) (f : Z ⟶ Y) :
    HigherFacesVanish q (f ≫ φ) 
goal: AlgebraicTopology.DoldKan.HigherFacesVanish q (f ≫ φ)

full_name: AlgebraicTopology.DoldKan.HigherFacesVanish.comp_Hσ_eq
code: theorem comp_Hσ_eq {Y : C} {n a q : ℕ} {φ : Y ⟶ X _[n + 1]} (v : HigherFacesVanish q φ)
    (hnaq : n = a + q) :
    φ ≫ (Hσ q).f (n + 1) =
      -φ ≫ X.δ ⟨a + 1, Nat.succ_lt_succ (Nat.lt_succ_iff.mpr (Nat.le.intro hnaq.symm))⟩ ≫
        X.σ ⟨a, Nat.lt_succ_iff.mpr (Nat.le.intro hnaq.symm)⟩ 
goal: φ ≫ (AlgebraicTopology.DoldKan.Hσ q).f (n + 1) = -φ ≫ X.δ ⟨a + 1, ⋯⟩ ≫ X.σ ⟨a, ⋯⟩

full_name: AlgebraicTopology.DoldKan.HigherFacesVanish.comp_Hσ_eq_zero
code: theorem comp_Hσ_eq_zero {Y : C} {n q : ℕ} {φ : Y ⟶ X _[n + 1]} (v : HigherFacesVanish q φ)
    (hqn : n < q) : φ ≫ (Hσ q).f (n + 1) = 0 
goal: φ ≫ (AlgebraicTopology.DoldKan.Hσ q).f (n + 1) = 0

full_name: AlgebraicTopology.DoldKan.HigherFacesVanish.induction
code: theorem induction {Y : C} {n q : ℕ} {φ : Y ⟶ X _[n + 1]} (v : HigherFacesVanish q φ) :
    HigherFacesVanish (q + 1) (φ ≫ (𝟙 _ + Hσ q).f (n + 1)) 
goal: AlgebraicTopology.DoldKan.HigherFacesVanish (q + 1)
  (φ ≫ (𝟙 (AlgebraicTopology.AlternatingFaceMapComplex.obj X) + AlgebraicTopology.DoldKan.Hσ q).f (n + 1))
File: Mathlib/SetTheory/Cardinal/Divisibility.lean

full_name: Cardinal.isUnit_iff
code: @[simp]
theorem isUnit_iff : IsUnit a ↔ a = 1 
goal: IsUnit a ↔ a = 1

full_name: Cardinal.instUniqueUnits
code: instance : Unique Cardinal.{u}ˣ 
goal: Unique Cardinal.{u}ˣ

full_name: Cardinal.le_of_dvd
code: theorem le_of_dvd : ∀ {a b : Cardinal}, b ≠ 0 → a ∣ b → a ≤ b
  
goal: b ≠ 0 → a ∣ b → a ≤ b

full_name: Cardinal.dvd_of_le_of_aleph0_le
code: theorem dvd_of_le_of_aleph0_le (ha : a ≠ 0) (h : a ≤ b) (hb : ℵ₀ ≤ b) : a ∣ b 
goal: a ∣ b

full_name: Cardinal.prime_of_aleph0_le
code: @[simp]
theorem prime_of_aleph0_le (ha : ℵ₀ ≤ a) : Prime a 
goal: Prime a

full_name: Cardinal.not_irreducible_of_aleph0_le
code: theorem not_irreducible_of_aleph0_le (ha : ℵ₀ ≤ a) : ¬Irreducible a 
goal: ¬Irreducible a

full_name: Cardinal.nat_coe_dvd_iff
code: @[simp, norm_cast]
theorem nat_coe_dvd_iff : (n : Cardinal) ∣ m ↔ n ∣ m 
goal: ↑n ∣ ↑m ↔ n ∣ m

full_name: Cardinal.nat_is_prime_iff
code: @[simp]
theorem nat_is_prime_iff : Prime (n : Cardinal) ↔ n.Prime 
goal: Prime ↑n ↔ Nat.Prime n

full_name: Cardinal.is_prime_iff
code: theorem is_prime_iff {a : Cardinal} : Prime a ↔ ℵ₀ ≤ a ∨ ∃ p : ℕ, a = p ∧ p.Prime 
goal: Prime a ↔ Cardinal.aleph0 ≤ a ∨ ∃ p, a = ↑p ∧ Nat.Prime p

full_name: Cardinal.isPrimePow_iff
code: theorem isPrimePow_iff {a : Cardinal} : IsPrimePow a ↔ ℵ₀ ≤ a ∨ ∃ n : ℕ, a = n ∧ IsPrimePow n 
goal: IsPrimePow a ↔ Cardinal.aleph0 ≤ a ∨ ∃ n, a = ↑n ∧ IsPrimePow n
File: Mathlib/Combinatorics/Quiver/ConnectedComponent.lean

full_name: Quiver.zigzagSetoid
code: /-- Two vertices are related in the zigzag setoid if there is a
    zigzag of arrows from one to the other. -/
def zigzagSetoid : Setoid V 
goal: Setoid V

full_name: Quiver.WeaklyConnectedComponent
code: /-- The type of weakly connected components of a directed graph. Two vertices are
    in the same weakly connected component if there is a zigzag of arrows from one
    to the other. -/
def WeaklyConnectedComponent : Type _ 
goal: Type u_1

full_name: Quiver.WeaklyConnectedComponent.mk
code: /-- The weakly connected component corresponding to a vertex. -/
protected def mk : V → WeaklyConnectedComponent V 
goal: V → Quiver.WeaklyConnectedComponent V

full_name: Quiver.WeaklyConnectedComponent.instCoeTC
code: instance : CoeTC V (WeaklyConnectedComponent V) 
goal: CoeTC V (Quiver.WeaklyConnectedComponent V)

full_name: Quiver.WeaklyConnectedComponent.instInhabited
code: instance [Inhabited V] : Inhabited (WeaklyConnectedComponent V) 
goal: Inhabited (Quiver.WeaklyConnectedComponent V)

full_name: Quiver.WeaklyConnectedComponent.eq
code: protected theorem eq (a b : V) :
    (a : WeaklyConnectedComponent V) = b ↔ Nonempty (@Path (Symmetrify V) _ a b) 
goal: Quiver.WeaklyConnectedComponent.mk a = Quiver.WeaklyConnectedComponent.mk b ↔ Nonempty (Quiver.Path a b)

full_name: Quiver.wideSubquiverSymmetrify
code: /-- A wide subquiver `H` of `Symmetrify V` determines a wide subquiver of `V`, containing an
    arrow `e` if either `e` or its reversal is in `H`. -/
def wideSubquiverSymmetrify (H : WideSubquiver (Symmetrify V)) : WideSubquiver V 
goal: WideSubquiver V
File: Mathlib/Combinatorics/Quiver/Push.lean

full_name: Quiver.Push
code: /-- The `Quiver` instance obtained by pushing arrows of `V` along the map `σ : V → W` -/
@[nolint unusedArguments]
def Push (_ : V → W) 
goal: (V → W) → Type u_2

full_name: Quiver.instNonemptyPush
code: instance [h : Nonempty W] : Nonempty (Push σ) 
goal: Nonempty (Quiver.Push σ)

full_name: Quiver.PushQuiver.arrow
code: /-- The quiver structure obtained by pushing arrows of `V` along the map `σ : V → W` -/
inductive PushQuiver {V : Type u} [Quiver.{v} V] {W : Type u₂} (σ : V → W) : W → W → Type max u u₂ v
  | arrow {X Y : V} (f : X ⟶ Y) : PushQuiver σ (σ X) (σ Y)
goal: Quiver.PushQuiver σ (σ X) (σ Y)

full_name: Quiver.PushQuiver
code: /-- The quiver structure obtained by pushing arrows of `V` along the map `σ : V → W` -/
inductive PushQuiver {V : Type u} [Quiver.{v} V] {W : Type u₂} (σ : V → W) : W → W → Type max u u₂ v
  | arrow {X Y : V} (f : X ⟶ Y) : PushQuiver σ (σ X) (σ Y)
goal: W → W → Type (max u u₂ v)

full_name: Quiver.instPush
code: instance : Quiver (Push σ) 
goal: Quiver (Quiver.Push σ)

full_name: Quiver.Push.of
code: /-- The prefunctor induced by pushing arrows via `σ` -/
def of : V ⥤q Push σ 
goal: V ⥤q Quiver.Push σ

full_name: Quiver.Push.of_obj
code: @[simp]
theorem of_obj : (of σ).obj = σ 
goal: (Quiver.Push.of σ).obj = σ

full_name: Quiver.Push.lift
code: /-- Given a function `τ : W → W'` and a prefunctor `φ : V ⥤q W'`, one can extend `τ` to be
a prefunctor `W ⥤q W'` if `τ` and `σ` factorize `φ` at the level of objects, where `W` is given
the pushforward quiver structure `Push σ`. -/
noncomputable def lift : Push σ ⥤q W' 
goal: Quiver.Push σ ⥤q W'

full_name: Quiver.Push.lift_obj
code: theorem lift_obj : (lift σ φ τ h).obj = τ 
goal: (Quiver.Push.lift σ φ τ h).obj = τ

full_name: Quiver.Push.lift_comp
code: theorem lift_comp : (of σ ⋙q lift σ φ τ h) = φ 
goal: Quiver.Push.of σ ⋙q Quiver.Push.lift σ φ τ h = φ

full_name: Quiver.Push.lift_unique
code: theorem lift_unique (Φ : Push σ ⥤q W') (Φ₀ : Φ.obj = τ) (Φcomp : (of σ ⋙q Φ) = φ) :
    Φ = lift σ φ τ h 
goal: Φ = Quiver.Push.lift σ φ τ h
File: Mathlib/Combinatorics/SetFamily/HarrisKleitman.lean

full_name: IsLowerSet.nonMemberSubfamily
code: theorem IsLowerSet.nonMemberSubfamily (h : IsLowerSet (𝒜 : Set (Finset α))) :
    IsLowerSet (𝒜.nonMemberSubfamily a : Set (Finset α)) 
goal: IsLowerSet ↑(Finset.nonMemberSubfamily a 𝒜)

full_name: IsLowerSet.memberSubfamily
code: theorem IsLowerSet.memberSubfamily (h : IsLowerSet (𝒜 : Set (Finset α))) :
    IsLowerSet (𝒜.memberSubfamily a : Set (Finset α)) 
goal: IsLowerSet ↑(Finset.memberSubfamily a 𝒜)

full_name: IsLowerSet.memberSubfamily_subset_nonMemberSubfamily
code: theorem IsLowerSet.memberSubfamily_subset_nonMemberSubfamily (h : IsLowerSet (𝒜 : Set (Finset α))) :
    𝒜.memberSubfamily a ⊆ 𝒜.nonMemberSubfamily a 
goal: Finset.memberSubfamily a 𝒜 ⊆ Finset.nonMemberSubfamily a 𝒜

full_name: IsLowerSet.le_card_inter_finset'
code: /-- **Harris-Kleitman inequality**: Any two lower sets of finsets correlate. -/
theorem IsLowerSet.le_card_inter_finset' (h𝒜 : IsLowerSet (𝒜 : Set (Finset α)))
    (hℬ : IsLowerSet (ℬ : Set (Finset α))) (h𝒜s : ∀ t ∈ 𝒜, t ⊆ s) (hℬs : ∀ t ∈ ℬ, t ⊆ s) :
    𝒜.card * ℬ.card ≤ 2 ^ s.card * (𝒜 ∩ ℬ).card 
goal: 𝒜.card * ℬ.card ≤ 2 ^ s.card * (𝒜 ∩ ℬ).card

full_name: IsLowerSet.le_card_inter_finset
code: /-- **Harris-Kleitman inequality**: Any two lower sets of finsets correlate. -/
theorem IsLowerSet.le_card_inter_finset (h𝒜 : IsLowerSet (𝒜 : Set (Finset α)))
    (hℬ : IsLowerSet (ℬ : Set (Finset α))) : 𝒜.card * ℬ.card ≤ 2 ^ Fintype.card α * (𝒜 ∩ ℬ).card 
goal: 𝒜.card * ℬ.card ≤ 2 ^ Fintype.card α * (𝒜 ∩ ℬ).card

full_name: IsUpperSet.card_inter_le_finset
code: /-- **Harris-Kleitman inequality**: Upper sets and lower sets of finsets anticorrelate. -/
theorem IsUpperSet.card_inter_le_finset (h𝒜 : IsUpperSet (𝒜 : Set (Finset α)))
    (hℬ : IsLowerSet (ℬ : Set (Finset α))) :
    2 ^ Fintype.card α * (𝒜 ∩ ℬ).card ≤ 𝒜.card * ℬ.card 
goal: 2 ^ Fintype.card α * (𝒜 ∩ ℬ).card ≤ 𝒜.card * ℬ.card

full_name: IsLowerSet.card_inter_le_finset
code: /-- **Harris-Kleitman inequality**: Lower sets and upper sets of finsets anticorrelate. -/
theorem IsLowerSet.card_inter_le_finset (h𝒜 : IsLowerSet (𝒜 : Set (Finset α)))
    (hℬ : IsUpperSet (ℬ : Set (Finset α))) :
    2 ^ Fintype.card α * (𝒜 ∩ ℬ).card ≤ 𝒜.card * ℬ.card 
goal: 2 ^ Fintype.card α * (𝒜 ∩ ℬ).card ≤ 𝒜.card * ℬ.card

full_name: IsUpperSet.le_card_inter_finset
code: /-- **Harris-Kleitman inequality**: Any two upper sets of finsets correlate. -/
theorem IsUpperSet.le_card_inter_finset (h𝒜 : IsUpperSet (𝒜 : Set (Finset α)))
    (hℬ : IsUpperSet (ℬ : Set (Finset α))) :
    𝒜.card * ℬ.card ≤ 2 ^ Fintype.card α * (𝒜 ∩ ℬ).card 
goal: 𝒜.card * ℬ.card ≤ 2 ^ Fintype.card α * (𝒜 ∩ ℬ).card
File: Mathlib/Combinatorics/SetFamily/Kleitman.lean

full_name: Finset.card_biUnion_le_of_intersecting
code: /-- **Kleitman's theorem**. An intersecting family on `n` elements contains at most `2ⁿ⁻¹` sets, and
each further intersecting family takes at most half of the sets that are in no previous family. -/
theorem Finset.card_biUnion_le_of_intersecting (s : Finset ι) (f : ι → Finset (Finset α))
    (hf : ∀ i ∈ s, (f i : Set (Finset α)).Intersecting) :
    (s.biUnion f).card ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - s.card) 
goal: (s.biUnion f).card ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - s.card)