ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Data/QPF/Multivariate/Constructions/Const.lean

full_name: MvQPF.Const
code: /-- Constant multivariate functor -/
@[nolint unusedArguments]
def Const (A : Type*) (_v : TypeVec.{u} n) : Type _ 
goal: Type u_1

full_name: MvQPF.Const.inhabited
code: instance Const.inhabited {A α} [Inhabited A] : Inhabited (Const n A α) 
goal: Inhabited (MvQPF.Const n A α)

full_name: MvQPF.Const.mk
code: /-- Constructor for constant functor -/
protected def mk (x : A) : Const n A α 
goal: MvQPF.Const n A α

full_name: MvQPF.Const.get
code: /-- Destructor for constant functor -/
protected def get (x : Const n A α) : A 
goal: A

full_name: MvQPF.Const.mk_get
code: @[simp]
protected theorem mk_get (x : Const n A α) : Const.mk (Const.get x) = x 
goal: MvQPF.Const.mk x.get = x

full_name: MvQPF.Const.get_mk
code: @[simp]
protected theorem get_mk (x : A) : Const.get (Const.mk x : Const n A α) = x 
goal: (MvQPF.Const.mk x).get = x

full_name: MvQPF.Const.map
code: /-- `map` for constant functor -/
protected def map : Const n A α → Const n A β 
goal: MvQPF.Const n A α → MvQPF.Const n A β

full_name: MvQPF.Const.MvFunctor
code: instance MvFunctor : MvFunctor (Const n A) 
goal: MvFunctor (MvQPF.Const n A)

full_name: MvQPF.Const.map_mk
code: theorem map_mk (x : A) : f <$$> Const.mk x = Const.mk x 
goal: MvFunctor.map f (MvQPF.Const.mk x) = MvQPF.Const.mk x

full_name: MvQPF.Const.get_map
code: theorem get_map (x : (Const n A) α) : Const.get (f <$$> x) = Const.get x 
goal: (MvFunctor.map f x).get = x.get

full_name: MvQPF.Const.mvqpf
code: instance mvqpf : @MvQPF _ (Const n A) 
goal: MvQPF (MvQPF.Const n A)
File: Mathlib/Data/QPF/Multivariate/Constructions/Sigma.lean

full_name: MvQPF.Sigma
code: /-- Dependent sum of an `n`-ary functor. The sum can range over
data types like `ℕ` or over `Type.{u-1}` -/
def Sigma (v : TypeVec.{u} n) : Type u 
goal: Type u

full_name: MvQPF.Pi
code: /-- Dependent product of an `n`-ary functor. The sum can range over
data types like `ℕ` or over `Type.{u-1}` -/
def Pi (v : TypeVec.{u} n) : Type u 
goal: Type u

full_name: MvQPF.Sigma.inhabited
code: instance Sigma.inhabited {α} [Inhabited A] [Inhabited (F default α)] : Inhabited (Sigma F α) 
goal: Inhabited (MvQPF.Sigma F α)

full_name: MvQPF.Pi.inhabited
code: instance Pi.inhabited {α} [∀ a, Inhabited (F a α)] : Inhabited (Pi F α) 
goal: Inhabited (MvQPF.Pi F α)

full_name: MvQPF.Sigma.instMvFunctor
code: instance [∀ α, MvFunctor <| F α] : MvFunctor (Sigma F) 
goal: MvFunctor (MvQPF.Sigma F)

full_name: MvQPF.Sigma.P
code: /-- polynomial functor representation of a dependent sum -/
protected def P : MvPFunctor n 
goal: MvPFunctor.{u} n

full_name: MvQPF.Sigma.abs
code: /-- abstraction function for dependent sums -/
protected def abs ⦃α⦄ : Sigma.P F α → Sigma F α
  
goal: ↑(MvQPF.Sigma.P F) α → MvQPF.Sigma F α

full_name: MvQPF.Sigma.repr
code: /-- representation function for dependent sums -/
protected def repr ⦃α⦄ : Sigma F α → Sigma.P F α
  
goal: MvQPF.Sigma F α → ↑(MvQPF.Sigma.P F) α

full_name: MvQPF.Sigma.inst
code: instance : MvQPF (Sigma F) 
goal: MvQPF (MvQPF.Sigma F)

full_name: MvQPF.Pi.instMvFunctor
code: instance [∀ α, MvFunctor <| F α] : MvFunctor (Pi F) 
goal: MvFunctor (MvQPF.Pi F)

full_name: MvQPF.Pi.P
code: /-- polynomial functor representation of a dependent product -/
protected def P : MvPFunctor n 
goal: MvPFunctor.{u} n

full_name: MvQPF.Pi.abs
code: /-- abstraction function for dependent products -/
protected def abs ⦃α⦄ : Pi.P F α → Pi F α
  
goal: ↑(MvQPF.Pi.P F) α → MvQPF.Pi F α

full_name: MvQPF.Pi.repr
code: /-- representation function for dependent products -/
protected def repr ⦃α⦄ : Pi F α → Pi.P F α
  
goal: MvQPF.Pi F α → ↑(MvQPF.Pi.P F) α

full_name: MvQPF.Pi.inst
code: instance : MvQPF (Pi F) 
goal: MvQPF (MvQPF.Pi F)
File: Mathlib/Data/QPF/Multivariate/Constructions/Comp.lean

full_name: MvQPF.Comp
code: /-- Composition of an `n`-ary functor with `n` `m`-ary
functors gives us one `m`-ary functor -/
def Comp (v : TypeVec.{u} m) : Type _ 
goal: Type u_1

full_name: MvQPF.Comp.instInhabited
code: instance [I : Inhabited (F fun i : Fin2 n ↦ G i α)] : Inhabited (Comp F G α) 
goal: Inhabited (MvQPF.Comp F G α)

full_name: MvQPF.Comp.mk
code: /-- Constructor for functor composition -/
protected def mk (x : F fun i ↦ G i α) : Comp F G α 
goal: MvQPF.Comp F G α

full_name: MvQPF.Comp.get
code: /-- Destructor for functor composition -/
protected def get (x : Comp F G α) : F fun i ↦ G i α 
goal: F fun i => G i α

full_name: MvQPF.Comp.mk_get
code: @[simp]
protected theorem mk_get (x : Comp F G α) : Comp.mk (Comp.get x) = x 
goal: MvQPF.Comp.mk x.get = x

full_name: MvQPF.Comp.get_mk
code: @[simp]
protected theorem get_mk (x : F fun i ↦ G i α) : Comp.get (Comp.mk x) = x 
goal: (MvQPF.Comp.mk x).get = x

full_name: MvQPF.Comp.map'
code: /-- map operation defined on a vector of functors -/
protected def map' : (fun i : Fin2 n ↦ G i α) ⟹ fun i : Fin2 n ↦ G i β 
goal: TypeVec.Arrow (fun i => G i α) fun i => G i β

full_name: MvQPF.Comp.map
code: /-- The composition of functors is itself functorial -/
protected def map : (Comp F G) α → (Comp F G) β 
goal: MvQPF.Comp F G α → MvQPF.Comp F G β

full_name: MvQPF.Comp.instMvFunctor
code: instance : MvFunctor (Comp F G) 
goal: MvFunctor (MvQPF.Comp F G)

full_name: MvQPF.Comp.map_mk
code: theorem map_mk (x : F fun i ↦ G i α) :
    f <$$> Comp.mk x = Comp.mk ((fun i (x : G i α) ↦ f <$$> x) <$$> x) 
goal: MvFunctor.map f (MvQPF.Comp.mk x) = MvQPF.Comp.mk (MvFunctor.map (fun i x => MvFunctor.map f x) x)

full_name: MvQPF.Comp.get_map
code: theorem get_map (x : Comp F G α) :
    Comp.get (f <$$> x) = (fun i (x : G i α) ↦ f <$$> x) <$$> Comp.get x 
goal: (MvFunctor.map f x).get = MvFunctor.map (fun i x => MvFunctor.map f x) x.get

full_name: MvQPF.Comp.inst
code: instance [MvQPF F] [∀ i, MvQPF <| G i] : MvQPF (Comp F G) 
goal: MvQPF (MvQPF.Comp F G)
File: Mathlib/Data/TypeMax.lean

full_name: TypeMax
code: /-- An alias for `Type max u v`, to deal around unification issues. -/
@[nolint checkUnivs, to_additive existing TypeMax]
abbrev TypeMax.{u, v} 
goal: Type ((max u v) + 1)
File: Mathlib/Data/Bool/Set.lean

full_name: Bool.univ_eq
code: @[simp]
theorem univ_eq : (univ : Set Bool) = {false, true} 
goal: Set.univ = {false, true}

full_name: Bool.range_eq
code: @[simp]
theorem range_eq {α : Type*} (f : Bool → α) : range f = {f false, f true} 
goal: Set.range f = {f false, f true}

full_name: Bool.compl_singleton
code: @[simp] theorem compl_singleton (b : Bool) : ({b}ᶜ : Set Bool) = {!b} 
goal: {b}ᶜ = {!b}
File: Mathlib/Data/Bool/AllAny.lean

full_name: List.all_iff_forall
code: theorem all_iff_forall {p : α → Bool} : all l p ↔ ∀ a ∈ l, p a 
goal: l.all p = true ↔ ∀ (a : α), a ∈ l → p a = true

full_name: List.all_iff_forall_prop
code: theorem all_iff_forall_prop : (all l fun a => p a) ↔ ∀ a ∈ l, p a 
goal: (l.all fun a => decide (p a)) = true ↔ ∀ (a : α), a ∈ l → p a

full_name: List.any_iff_exists
code: theorem any_iff_exists {p : α → Bool} : any l p ↔ ∃ a ∈ l, p a 
goal: l.any p = true ↔ ∃ a, a ∈ l ∧ p a = true

full_name: List.any_iff_exists_prop
code: theorem any_iff_exists_prop : (any l fun a => p a) ↔ ∃ a ∈ l, p a 
goal: (l.any fun a => decide (p a)) = true ↔ ∃ a, a ∈ l ∧ p a

full_name: List.any_of_mem
code: theorem any_of_mem {p : α → Bool} (h₁ : a ∈ l) (h₂ : p a) : any l p 
goal: l.any p = true
File: Mathlib/Data/Fintype/Lattice.lean

full_name: Finset.sup_univ_eq_iSup
code: /-- A special case of `Finset.sup_eq_iSup` that omits the useless `x ∈ univ` binder. -/
theorem sup_univ_eq_iSup [CompleteLattice β] (f : α → β) : Finset.univ.sup f = iSup f 
goal: Finset.univ.sup f = iSup f

full_name: Finset.inf_univ_eq_iInf
code: /-- A special case of `Finset.inf_eq_iInf` that omits the useless `x ∈ univ` binder. -/
theorem inf_univ_eq_iInf [CompleteLattice β] (f : α → β) : Finset.univ.inf f = iInf f 
goal: Finset.univ.inf f = iInf f

full_name: Finset.fold_inf_univ
code: @[simp]
theorem fold_inf_univ [SemilatticeInf α] [OrderBot α] (a : α) :
    -- Porting note: added `haveI`
    haveI : Std.Commutative (α := α) (· ⊓ ·) := inferInstance
    (Finset.univ.fold (· ⊓ ·) a fun x => x) = ⊥ 
goal: Finset.fold (fun x x_1 => x ⊓ x_1) a (fun x => x) Finset.univ = ⊥

full_name: Finset.fold_sup_univ
code: @[simp]
theorem fold_sup_univ [SemilatticeSup α] [OrderTop α] (a : α) :
    -- Porting note: added `haveI`
    haveI : Std.Commutative (α := α) (· ⊔ ·) := inferInstance
    (Finset.univ.fold (· ⊔ ·) a fun x => x) = ⊤ 
goal: Finset.fold (fun x x_1 => x ⊔ x_1) a (fun x => x) Finset.univ = ⊤

full_name: Finset.mem_inf
code: lemma mem_inf [DecidableEq α] {s : Finset ι} {f : ι → Finset α} {a : α} :
    a ∈ s.inf f ↔ ∀ i ∈ s, a ∈ f i 
goal: a ∈ s.inf f ↔ ∀ i ∈ s, a ∈ f i

full_name: Finite.exists_max
code: theorem Finite.exists_max [Finite α] [Nonempty α] [LinearOrder β] (f : α → β) :
    ∃ x₀ : α, ∀ x, f x ≤ f x₀ 
goal: ∃ x₀, ∀ (x : α), f x ≤ f x₀

full_name: Finite.exists_min
code: theorem Finite.exists_min [Finite α] [Nonempty α] [LinearOrder β] (f : α → β) :
    ∃ x₀ : α, ∀ x, f x₀ ≤ f x 
goal: ∃ x₀, ∀ (x : α), f x₀ ≤ f x
File: Mathlib/Data/Fintype/Parity.lean

full_name: Fintype.IsSquare.decidablePred
code: instance IsSquare.decidablePred [Mul α] [Fintype α] [DecidableEq α] :
    DecidablePred (IsSquare : α → Prop) 
goal: DecidablePred IsSquare

full_name: Fintype.card_fin_two
code: /-- The cardinality of `Fin 2` is even, `Fact` version.
This `Fact` is needed as an instance by `Matrix.SpecialLinearGroup.instNeg`. -/
instance card_fin_two : Fact (Even (Fintype.card (Fin 2))) 
goal: Fact (Even (Fintype.card (Fin 2)))
File: Mathlib/Data/Fintype/Fin.lean

full_name: Fin.map_valEmbedding_univ
code: theorem map_valEmbedding_univ : (Finset.univ : Finset (Fin n)).map Fin.valEmbedding = Iio n 
goal: Finset.map Fin.valEmbedding Finset.univ = Finset.Iio n

full_name: Fin.Ioi_zero_eq_map
code: @[simp]
theorem Ioi_zero_eq_map : Ioi (0 : Fin n.succ) = univ.map (Fin.succEmb _) 
goal: Finset.Ioi 0 = Finset.map (Fin.succEmb n) Finset.univ

full_name: Fin.Iio_last_eq_map
code: @[simp]
theorem Iio_last_eq_map : Iio (Fin.last n) = Finset.univ.map Fin.castSuccEmb 
goal: Finset.Iio (Fin.last n) = Finset.map Fin.castSuccEmb Finset.univ

full_name: Fin.Ioi_succ
code: @[simp]
theorem Ioi_succ (i : Fin n) : Ioi i.succ = (Ioi i).map (Fin.succEmb _) 
goal: Finset.Ioi i.succ = Finset.map (Fin.succEmb n) (Finset.Ioi i)

full_name: Fin.Iio_castSucc
code: @[simp]
theorem Iio_castSucc (i : Fin n) : Iio (castSucc i) = (Iio i).map Fin.castSuccEmb 
goal: Finset.Iio i.castSucc = Finset.map Fin.castSuccEmb (Finset.Iio i)

full_name: Fin.card_filter_univ_succ'
code: theorem card_filter_univ_succ' (p : Fin (n + 1) → Prop) [DecidablePred p] :
    (univ.filter p).card = ite (p 0) 1 0 + (univ.filter (p ∘ Fin.succ)).card 
goal: (Finset.filter p Finset.univ).card = (if p 0 then 1 else 0) + (Finset.filter (p ∘ Fin.succ) Finset.univ).card

full_name: Fin.card_filter_univ_succ
code: theorem card_filter_univ_succ (p : Fin (n + 1) → Prop) [DecidablePred p] :
    (univ.filter p).card =
    if p 0 then (univ.filter (p ∘ Fin.succ)).card + 1 else (univ.filter (p ∘ Fin.succ)).card 
goal: (Finset.filter p Finset.univ).card =
  if p 0 then (Finset.filter (p ∘ Fin.succ) Finset.univ).card + 1 else (Finset.filter (p ∘ Fin.succ) Finset.univ).card

full_name: Fin.card_filter_univ_eq_vector_get_eq_count
code: theorem card_filter_univ_eq_vector_get_eq_count [DecidableEq α] (a : α) (v : Vector α n) :
    (univ.filter fun i => a = v.get i).card = v.toList.count a 
goal: (Finset.filter (fun i => a = v.get i) Finset.univ).card = List.count a v.toList
File: Mathlib/Data/Fintype/Units.lean

full_name: UnitsInt.fintype
code: instance UnitsInt.fintype : Fintype ℤˣ 
goal: Fintype ℤˣ

full_name: UnitsInt.univ
code: @[simp]
theorem UnitsInt.univ : (Finset.univ : Finset ℤˣ) = {1, -1} 
goal: Finset.univ = {1, -1}

full_name: Fintype.card_units_int
code: @[simp]
theorem Fintype.card_units_int : Fintype.card ℤˣ = 2 
goal: Fintype.card ℤˣ = 2

full_name: instFintypeUnitsOfDecidableEq
code: instance [Monoid α] [Fintype α] [DecidableEq α] : Fintype αˣ 
goal: Fintype αˣ

full_name: instFiniteUnits
code: instance [Monoid α] [Finite α] : Finite αˣ 
goal: Finite αˣ

full_name: Fintype.card_eq_card_units_add_one
code: theorem Fintype.card_eq_card_units_add_one [GroupWithZero α] [Fintype α] [DecidableEq α] :
    Fintype.card α = Fintype.card αˣ + 1 
goal: Fintype.card α = Fintype.card αˣ + 1

full_name: Nat.card_eq_card_units_add_one
code: theorem Nat.card_eq_card_units_add_one [GroupWithZero α] [Finite α] :
    Nat.card α = Nat.card αˣ + 1 
goal: Nat.card α = Nat.card αˣ + 1

full_name: Fintype.card_units
code: theorem Fintype.card_units [GroupWithZero α] [Fintype α] [DecidableEq α] :
    Fintype.card αˣ = Fintype.card α - 1 
goal: Fintype.card αˣ = Fintype.card α - 1
File: Mathlib/Data/Fintype/Quotient.lean

full_name: Quotient.finChoiceAux
code: /-- An auxiliary function for `Quotient.finChoice`.  Given a
collection of setoids indexed by a type `ι`, a (finite) list `l` of
indices, and a function that for each `i ∈ l` gives a term of the
corresponding quotient type, then there is a corresponding term in the
quotient of the product of the setoids indexed by `l`. -/
def Quotient.finChoiceAux {ι : Type*} [DecidableEq ι] {α : ι → Type*} [S : ∀ i, Setoid (α i)] :
    ∀ l : List ι, (∀ i ∈ l, Quotient (S i)) → @Quotient (∀ i ∈ l, α i) (by infer_instance)
  
goal: ((i : ι) → i ∈ l → Quotient (S i)) → Quotient inferInstance

full_name: Quotient.finChoiceAux_eq
code: theorem Quotient.finChoiceAux_eq {ι : Type*} [DecidableEq ι] {α : ι → Type*}
    [S : ∀ i, Setoid (α i)] :
    ∀ (l : List ι) (f : ∀ i ∈ l, α i), (Quotient.finChoiceAux l fun i h => ⟦f i h⟧) = ⟦f⟧
  
goal: (Quotient.finChoiceAux l fun i h => ⟦f i h⟧) = ⟦f⟧

full_name: Quotient.finChoice
code: /-- Given a collection of setoids indexed by a fintype `ι` and a
function that for each `i : ι` gives a term of the corresponding
quotient type, then there is corresponding term in the quotient of the
product of the setoids. -/
def Quotient.finChoice {ι : Type*} [DecidableEq ι] [Fintype ι] {α : ι → Type*}
    [S : ∀ i, Setoid (α i)] (f : ∀ i, Quotient (S i)) : @Quotient (∀ i, α i) (by infer_instance) 
goal: Quotient inferInstance

full_name: Quotient.finChoice_eq
code: theorem Quotient.finChoice_eq {ι : Type*} [DecidableEq ι] [Fintype ι] {α : ι → Type*}
    [∀ i, Setoid (α i)] (f : ∀ i, α i) : (Quotient.finChoice fun i => ⟦f i⟧) = ⟦f⟧ 
goal: (Quotient.finChoice fun i => ⟦f i⟧) = ⟦f⟧

full_name: Trunc.finChoice
code: /-- Given a function that for each `i : ι` gives a term of the corresponding
truncation type, then there is corresponding term in the truncation of the product. -/
def Trunc.finChoice {ι : Type*} [DecidableEq ι] [Fintype ι] {α : ι → Type*}
    (f : ∀ i, Trunc (α i)) : Trunc (∀ i, α i) 
goal: Trunc ((i : ι) → α i)

full_name: Trunc.finChoice_eq
code: theorem Trunc.finChoice_eq {ι : Type*} [DecidableEq ι] [Fintype ι] {α : ι → Type*}
    (f : ∀ i, α i) : (Trunc.finChoice fun i => Trunc.mk (f i)) = Trunc.mk f 
goal: (Trunc.finChoice fun i => Trunc.mk (f i)) = Trunc.mk f
File: Mathlib/Data/Fintype/List.lean

full_name: Multiset.lists
code: /-- The `Finset` of `l : List α` that, given `m : Multiset α`, have the property `⟦l⟧ = m`.
-/
def lists : Multiset α → Finset (List α) 
goal: Multiset α → Finset (List α)

full_name: Multiset.lists_coe
code: @[simp]
theorem lists_coe (l : List α) : lists (l : Multiset α) = l.permutations.toFinset 
goal: (↑l).lists = l.permutations.toFinset

full_name: Multiset.mem_lists_iff
code: @[simp]
theorem mem_lists_iff (s : Multiset α) (l : List α) : l ∈ lists s ↔ s = ⟦l⟧ 
goal: l ∈ s.lists ↔ s = ⟦l⟧

full_name: fintypeNodupList
code: instance fintypeNodupList [Fintype α] : Fintype { l : List α // l.Nodup } 
goal: Fintype { l // l.Nodup }
File: Mathlib/Data/Fintype/Vector.lean

full_name: Vector.fintype
code: instance Vector.fintype [Fintype α] {n : ℕ} : Fintype (Vector α n) 
goal: Fintype (Mathlib.Vector α n)

full_name: instFintypeSym'OfDecidableEq
code: instance [DecidableEq α] [Fintype α] {n : ℕ} : Fintype (Sym.Sym' α n) 
goal: Fintype (Sym.Sym' α n)

full_name: instFintypeSymOfDecidableEq
code: instance [DecidableEq α] [Fintype α] {n : ℕ} : Fintype (Sym α n) 
goal: Fintype (Sym α n)
File: Mathlib/Data/Fintype/Sort.lean

full_name: monoEquivOfFin
code: /-- Given a linearly ordered fintype `α` of cardinal `k`, the order isomorphism
`monoEquivOfFin α h` is the increasing bijection between `Fin k` and `α`. Here, `h` is a proof
that the cardinality of `α` is `k`. We use this instead of an isomorphism `Fin (card α) ≃o α` to
avoid casting issues in further uses of this function. -/
def monoEquivOfFin (α : Type*) [Fintype α] [LinearOrder α] {k : ℕ} (h : Fintype.card α = k) :
    Fin k ≃o α 
goal: Fin k ≃o α

full_name: finSumEquivOfFinset
code: /-- If `α` is a linearly ordered fintype, `s : Finset α` has cardinality `m` and its complement has
cardinality `n`, then `Fin m ⊕ Fin n ≃ α`. The equivalence sends elements of `Fin m` to
elements of `s` and elements of `Fin n` to elements of `sᶜ` while preserving order on each
"half" of `Fin m ⊕ Fin n` (using `Set.orderIsoOfFin`). -/
def finSumEquivOfFinset (hm : s.card = m) (hn : sᶜ.card = n) : Fin m ⊕ Fin n ≃ α 
goal: Fin m ⊕ Fin n ≃ α

full_name: finSumEquivOfFinset_inl
code: @[simp]
theorem finSumEquivOfFinset_inl (hm : s.card = m) (hn : sᶜ.card = n) (i : Fin m) :
    finSumEquivOfFinset hm hn (Sum.inl i) = s.orderEmbOfFin hm i 
goal: (finSumEquivOfFinset hm hn) (Sum.inl i) = (s.orderEmbOfFin hm) i

full_name: finSumEquivOfFinset_inr
code: @[simp]
theorem finSumEquivOfFinset_inr (hm : s.card = m) (hn : sᶜ.card = n) (i : Fin n) :
    finSumEquivOfFinset hm hn (Sum.inr i) = sᶜ.orderEmbOfFin hn i 
goal: (finSumEquivOfFinset hm hn) (Sum.inr i) = (sᶜ.orderEmbOfFin hn) i
File: Mathlib/Data/Fintype/Powerset.lean

full_name: Finset.fintype
code: instance Finset.fintype [Fintype α] : Fintype (Finset α) 
goal: Fintype (Finset α)

full_name: Fintype.card_finset
code: @[simp]
theorem Fintype.card_finset [Fintype α] : Fintype.card (Finset α) = 2 ^ Fintype.card α 
goal: Fintype.card (Finset α) = 2 ^ Fintype.card α

full_name: Finset.powerset_univ
code: @[simp] lemma powerset_univ : (univ : Finset α).powerset = univ 
goal: Finset.univ.powerset = Finset.univ

full_name: Finset.filter_subset_univ
code: lemma filter_subset_univ [DecidableEq α] (s : Finset α) :
    filter (fun t ↦ t ⊆ s) univ = powerset s 
goal: Finset.filter (fun t => t ⊆ s) Finset.univ = s.powerset

full_name: Finset.powerset_eq_univ
code: @[simp] lemma powerset_eq_univ : s.powerset = univ ↔ s = univ 
goal: s.powerset = Finset.univ ↔ s = Finset.univ

full_name: Finset.mem_powersetCard_univ
code: lemma mem_powersetCard_univ : s ∈ powersetCard k (univ : Finset α) ↔ card s = k 
goal: s ∈ Finset.powersetCard k Finset.univ ↔ s.card = k

full_name: Finset.univ_filter_card_eq
code: @[simp] lemma univ_filter_card_eq (k : ℕ) :
    (univ : Finset (Finset α)).filter (fun s ↦ s.card = k) = univ.powersetCard k 
goal: Finset.filter (fun s => s.card = k) Finset.univ = Finset.powersetCard k Finset.univ

full_name: Fintype.card_finset_len
code: @[simp]
theorem Fintype.card_finset_len [Fintype α] (k : ℕ) :
    Fintype.card { s : Finset α // s.card = k } = Nat.choose (Fintype.card α) k 
goal: Fintype.card { s // s.card = k } = (Fintype.card α).choose k

full_name: Set.fintype
code: instance Set.fintype [Fintype α] : Fintype (Set α) 
goal: Fintype (Set α)

full_name: Set.finite'
code: instance Set.finite' [Finite α] : Finite (Set α) 
goal: Finite (Set α)

full_name: Fintype.card_set
code: @[simp]
theorem Fintype.card_set [Fintype α] : Fintype.card (Set α) = 2 ^ Fintype.card α 
goal: Fintype.card (Set α) = 2 ^ Fintype.card α
File: Mathlib/Data/Fintype/CardEmbedding.lean

full_name: «_aux_Mathlib_Data_Fintype_CardEmbedding___macroRules_term|_|_1»
code: local notation "|" x "|" => Finset.card x
goal: Lean.Macro

full_name: _aux_Mathlib_Data_Fintype_CardEmbedding___unexpand_Finset_card_1
code: local notation "|" x "|" => Finset.card x
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Data_Fintype_CardEmbedding___macroRules_term‖_‖_1»
code: local notation "‖" x "‖" => Fintype.card x
goal: Lean.Macro

full_name: _aux_Mathlib_Data_Fintype_CardEmbedding___unexpand_Fintype_card_1
code: local notation "‖" x "‖" => Fintype.card x
goal: Lean.PrettyPrinter.Unexpander

full_name: Fintype.card_embedding_eq_of_unique
code: theorem card_embedding_eq_of_unique {α β : Type*} [Unique α] [Fintype β] [Fintype (α ↪ β)] :
    ‖α ↪ β‖ = ‖β‖ 
goal: ‖α ↪ β‖ = ‖β‖

full_name: Fintype.card_embedding_eq
code: @[simp]
theorem card_embedding_eq {α β : Type*} [Fintype α] [Fintype β] [emb : Fintype (α ↪ β)] :
    ‖α ↪ β‖ = ‖β‖.descFactorial ‖α‖ 
goal: ‖α ↪ β‖ = ‖β‖.descFactorial ‖α‖

full_name: Fintype.card_embedding_eq_of_infinite
code: /-- The cardinality of embeddings from an infinite type to a finite type is zero.
This is a re-statement of the pigeonhole principle. -/
theorem card_embedding_eq_of_infinite {α β : Type*} [Infinite α] [Fintype β] [Fintype (α ↪ β)] :
    ‖α ↪ β‖ = 0 
goal: ‖α ↪ β‖ = 0
File: Mathlib/Data/Fintype/Prod.lean

full_name: Set.toFinset_prod
code: theorem toFinset_prod (s : Set α) (t : Set β) [Fintype s] [Fintype t] [Fintype (s ×ˢ t)] :
    (s ×ˢ t).toFinset = s.toFinset ×ˢ t.toFinset 
goal: (s ×ˢ t).toFinset = s.toFinset ×ˢ t.toFinset

full_name: Set.toFinset_off_diag
code: theorem toFinset_off_diag {s : Set α} [DecidableEq α] [Fintype s] [Fintype s.offDiag] :
    s.offDiag.toFinset = s.toFinset.offDiag 
goal: s.offDiag.toFinset = s.toFinset.offDiag

full_name: instFintypeProd
code: instance instFintypeProd (α β : Type*) [Fintype α] [Fintype β] : Fintype (α × β) 
goal: Fintype (α × β)

full_name: Finset.univ_product_univ
code: @[simp] lemma univ_product_univ : univ ×ˢ univ = (univ : Finset (α × β)) 
goal: Finset.univ ×ˢ Finset.univ = Finset.univ

full_name: Finset.product_eq_univ
code: @[simp] lemma product_eq_univ [Nonempty α] [Nonempty β] : s ×ˢ t = univ ↔ s = univ ∧ t = univ 
goal: s ×ˢ t = Finset.univ ↔ s = Finset.univ ∧ t = Finset.univ

full_name: Fintype.card_prod
code: @[simp]
theorem Fintype.card_prod (α β : Type*) [Fintype α] [Fintype β] :
    Fintype.card (α × β) = Fintype.card α * Fintype.card β 
goal: Fintype.card (α × β) = Fintype.card α * Fintype.card β

full_name: infinite_prod
code: @[simp]
theorem infinite_prod : Infinite (α × β) ↔ Infinite α ∧ Nonempty β ∨ Nonempty α ∧ Infinite β 
goal: Infinite (α × β) ↔ Infinite α ∧ Nonempty β ∨ Nonempty α ∧ Infinite β

full_name: Pi.infinite_of_left
code: instance Pi.infinite_of_left {ι : Sort*} {π : ι → Type*} [∀ i, Nontrivial <| π i] [Infinite ι] :
    Infinite (∀ i : ι, π i) 
goal: Infinite ((i : ι) → π i)

full_name: Pi.infinite_of_exists_right
code: /-- If at least one `π i` is infinite and the rest nonempty, the pi type of all `π` is infinite. -/
theorem Pi.infinite_of_exists_right {ι : Sort*} {π : ι → Sort*} (i : ι) [Infinite <| π i]
    [∀ i, Nonempty <| π i] : Infinite (∀ i : ι, π i) 
goal: Infinite ((i : ι) → π i)

full_name: Pi.infinite_of_right
code: /-- See `Pi.infinite_of_exists_right` for the case that only one `π i` is infinite. -/
instance Pi.infinite_of_right {ι : Sort*} {π : ι → Type*} [∀ i, Infinite <| π i] [Nonempty ι] :
    Infinite (∀ i : ι, π i) 
goal: Infinite ((i : ι) → π i)

full_name: Function.infinite_of_left
code: /-- Non-dependent version of `Pi.infinite_of_left`. -/
instance Function.infinite_of_left {ι : Sort*} {π : Type*} [Nontrivial π] [Infinite ι] :
    Infinite (ι → π) 
goal: Infinite (ι → π)

full_name: Function.infinite_of_right
code: /-- Non-dependent version of `Pi.infinite_of_exists_right` and `Pi.infinite_of_right`. -/
instance Function.infinite_of_right {ι : Sort*} {π : Type*} [Infinite π] [Nonempty ι] :
    Infinite (ι → π) 
goal: Infinite (ι → π)
File: Mathlib/Data/Fintype/Shrink.lean

full_name: Shrink.instFintype
code: noncomputable instance Shrink.instFintype : Fintype (Shrink.{v} α) 
goal: Fintype (Shrink.{v, u} α)

full_name: Shrink.instFinite
code: instance Shrink.instFinite {α : Type u} [Finite α] : Finite (Shrink.{v} α) 
goal: Finite (Shrink.{v, u} α)

full_name: Fintype.card_shrink
code: @[simp] lemma Fintype.card_shrink [Fintype (Shrink.{v} α)] : card (Shrink.{v} α) = card α 
goal: Fintype.card (Shrink.{v, u} α) = Fintype.card α