ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Data/Fintype/Option.lean

full_name: instFintypeOption
code: instance {α : Type*} [Fintype α] : Fintype (Option α) 
goal: Fintype (Option α)

full_name: univ_option
code: theorem univ_option (α : Type*) [Fintype α] : (univ : Finset (Option α)) = insertNone univ 
goal: Finset.univ = Finset.insertNone Finset.univ

full_name: Fintype.card_option
code: @[simp]
theorem Fintype.card_option {α : Type*} [Fintype α] :
    Fintype.card (Option α) = Fintype.card α + 1 
goal: Fintype.card (Option α) = Fintype.card α + 1

full_name: fintypeOfOption
code: /-- If `Option α` is a `Fintype` then so is `α` -/
def fintypeOfOption {α : Type*} [Fintype (Option α)] : Fintype α 
goal: Fintype α

full_name: fintypeOfOptionEquiv
code: /-- A type is a `Fintype` if its successor (using `Option`) is a `Fintype`. -/
def fintypeOfOptionEquiv [Fintype α] (f : α ≃ Option β) : Fintype β 
goal: Fintype β

full_name: Fintype.truncRecEmptyOption
code: /-- A recursor principle for finite types, analogous to `Nat.rec`. It effectively says
that every `Fintype` is either `Empty` or `Option α`, up to an `Equiv`. -/
def truncRecEmptyOption {P : Type u → Sort v} (of_equiv : ∀ {α β}, α ≃ β → P α → P β)
    (h_empty : P PEmpty) (h_option : ∀ {α} [Fintype α] [DecidableEq α], P α → P (Option α))
    (α : Type u) [Fintype α] [DecidableEq α] : Trunc (P α) 
goal: Trunc (P α)

full_name: Fintype.truncRecEmptyOption.ind
code: /-- A recursor principle for finite types, analogous to `Nat.rec`. It effectively says
that every `Fintype` is either `Empty` or `Option α`, up to an `Equiv`. -/
def truncRecEmptyOption {P : Type u → Sort v} (of_equiv : ∀ {α β}, α ≃ β → P α → P β)
    (h_empty : P PEmpty) (h_option : ∀ {α} [Fintype α] [DecidableEq α], P α → P (Option α))
    (α : Type u) [Fintype α] [DecidableEq α] : Trunc (P α) 
goal: Trunc (P (ULift.{u, 0} (Fin n)))

full_name: Fintype.induction_empty_option
code: /-- An induction principle for finite types, analogous to `Nat.rec`. It effectively says
that every `Fintype` is either `Empty` or `Option α`, up to an `Equiv`. -/
@[elab_as_elim]
theorem induction_empty_option {P : ∀ (α : Type u) [Fintype α], Prop}
    (of_equiv : ∀ (α β) [Fintype β] (e : α ≃ β), @P α (@Fintype.ofEquiv α β ‹_› e.symm) → @P β ‹_›)
    (h_empty : P PEmpty) (h_option : ∀ (α) [Fintype α], P α → P (Option α)) (α : Type u)
    [h_fintype : Fintype α] : P α 
goal: P α

full_name: Finite.induction_empty_option
code: /-- An induction principle for finite types, analogous to `Nat.rec`. It effectively says
that every `Fintype` is either `Empty` or `Option α`, up to an `Equiv`. -/
theorem Finite.induction_empty_option {P : Type u → Prop} (of_equiv : ∀ {α β}, α ≃ β → P α → P β)
    (h_empty : P PEmpty) (h_option : ∀ {α} [Fintype α], P α → P (Option α)) (α : Type u)
    [Finite α] : P α 
goal: P α
File: Mathlib/Data/LazyList/Basic.lean

full_name: LazyList.listEquivLazyList
code: /-- Isomorphism between strict and lazy lists. -/
@[deprecated (since := "2024-07-22")]
def listEquivLazyList (α : Type*) : List α ≃ LazyList α 
goal: List α ≃ LazyList α

full_name: LazyList.instTraversable
code: @[deprecated (since := "2024-07-22")]
instance : Traversable LazyList 
goal: Traversable LazyList

full_name: LazyList.instLawfulTraversable
code: @[deprecated (since := "2024-07-22")]
instance : LawfulTraversable LazyList 
goal: LawfulTraversable LazyList

full_name: LazyList.bind_singleton
code: @[deprecated (since := "2024-07-22"), simp]
theorem bind_singleton {α} (x : LazyList α) : x.bind singleton = x 
goal: x.bind LazyList.singleton = x

full_name: LazyList.instLawfulMonad_mathlib
code: @[deprecated (since := "2024-07-22")]
instance : LawfulMonad LazyList 
goal: LawfulMonad LazyList
File: Mathlib/Data/PNat/Equiv.lean

full_name: Equiv.pnatEquivNat
code: /-- An equivalence between `ℕ+` and `ℕ` given by `PNat.natPred` and `Nat.succPNat`. -/
@[simps (config := .asFn)]
def _root_.Equiv.pnatEquivNat : ℕ+ ≃ ℕ 
goal: ℕ+ ≃ ℕ

full_name: Equiv.pnatEquivNat_apply
code: /-- An equivalence between `ℕ+` and `ℕ` given by `PNat.natPred` and `Nat.succPNat`. -/
@[simps (config := .asFn)]
def _root_.Equiv.pnatEquivNat : ℕ+ ≃ ℕ 
goal: ⇑Equiv.pnatEquivNat = PNat.natPred

full_name: Equiv.pnatEquivNat_symm_apply
code: /-- An equivalence between `ℕ+` and `ℕ` given by `PNat.natPred` and `Nat.succPNat`. -/
@[simps (config := .asFn)]
def _root_.Equiv.pnatEquivNat : ℕ+ ≃ ℕ 
goal: ⇑Equiv.pnatEquivNat.symm = Nat.succPNat
File: Mathlib/Data/Fintype/Perm.lean

full_name: permsOfList
code: /-- Given a list, produce a list of all permutations of its elements. -/
def permsOfList : List α → List (Perm α)
  
goal: List α → List (Equiv.Perm α)

full_name: length_permsOfList
code: theorem length_permsOfList : ∀ l : List α, length (permsOfList l) = l.length !
  
goal: (permsOfList l).length = l.length !

full_name: mem_permsOfList_of_mem
code: theorem mem_permsOfList_of_mem {l : List α} {f : Perm α} (h : ∀ x, f x ≠ x → x ∈ l) :
    f ∈ permsOfList l 
goal: f ∈ permsOfList l

full_name: mem_of_mem_permsOfList
code: theorem mem_of_mem_permsOfList :
    -- Porting note: was `∀ {x}` but need to capture the `x`
    ∀ {l : List α} {f : Perm α}, f ∈ permsOfList l → (x : α ) → f x ≠ x → x ∈ l
  
goal: f ∈ permsOfList l → ∀ (x : α), f x ≠ x → x ∈ l

full_name: mem_permsOfList_iff
code: theorem mem_permsOfList_iff {l : List α} {f : Perm α} :
    f ∈ permsOfList l ↔ ∀ {x}, f x ≠ x → x ∈ l 
goal: f ∈ permsOfList l ↔ ∀ {x : α}, f x ≠ x → x ∈ l

full_name: nodup_permsOfList
code: theorem nodup_permsOfList : ∀ {l : List α}, l.Nodup → (permsOfList l).Nodup
  
goal: l.Nodup → (permsOfList l).Nodup

full_name: permsOfFinset
code: /-- Given a finset, produce the finset of all permutations of its elements. -/
def permsOfFinset (s : Finset α) : Finset (Perm α) 
goal: Finset (Equiv.Perm α)

full_name: mem_perms_of_finset_iff
code: theorem mem_perms_of_finset_iff :
    ∀ {s : Finset α} {f : Perm α}, f ∈ permsOfFinset s ↔ ∀ {x}, f x ≠ x → x ∈ s 
goal: f ∈ permsOfFinset s ↔ ∀ {x : α}, f x ≠ x → x ∈ s

full_name: card_perms_of_finset
code: theorem card_perms_of_finset : ∀ s : Finset α, (permsOfFinset s).card = s.card ! 
goal: (permsOfFinset s).card = s.card !

full_name: fintypePerm
code: /-- The collection of permutations of a fintype is a fintype. -/
def fintypePerm [Fintype α] : Fintype (Perm α) 
goal: Fintype (Equiv.Perm α)

full_name: equivFintype
code: instance equivFintype [Fintype α] [Fintype β] : Fintype (α ≃ β) 
goal: Fintype (α ≃ β)

full_name: Fintype.card_perm
code: theorem Fintype.card_perm [Fintype α] : Fintype.card (Perm α) = (Fintype.card α)! 
goal: Fintype.card (Equiv.Perm α) = (Fintype.card α)!

full_name: Fintype.card_equiv
code: theorem Fintype.card_equiv [Fintype α] [Fintype β] (e : α ≃ β) :
    Fintype.card (α ≃ β) = (Fintype.card α)! 
goal: Fintype.card (α ≃ β) = (Fintype.card α)!
File: Mathlib/Data/Fintype/Sigma.lean

full_name: Set.biUnion_finsetSigma_univ
code: lemma Set.biUnion_finsetSigma_univ (s : Finset ι) (f : Sigma κ → Set α) :
    ⋃ ij ∈ s.sigma fun _ ↦ Finset.univ, f ij = ⋃ i ∈ s, ⋃ j, f ⟨i, j⟩ 
goal: ⋃ ij ∈ s.sigma fun x => Finset.univ, f ij = ⋃ i ∈ s, ⋃ j, f ⟨i, j⟩

full_name: Set.biUnion_finsetSigma_univ'
code: lemma Set.biUnion_finsetSigma_univ' (s : Finset ι) (f : Π i, κ i → Set α) :
    ⋃ i ∈ s, ⋃ j, f i j = ⋃ ij ∈ s.sigma fun _ ↦ Finset.univ, f ij.1 ij.2 
goal: ⋃ i ∈ s, ⋃ j, f i j = ⋃ ij ∈ s.sigma fun x => Finset.univ, f ij.fst ij.snd

full_name: Set.biInter_finsetSigma_univ
code: lemma Set.biInter_finsetSigma_univ (s : Finset ι) (f : Sigma κ → Set α) :
    ⋂ ij ∈ s.sigma fun _ ↦ Finset.univ, f ij = ⋂ i ∈ s, ⋂ j, f ⟨i, j⟩ 
goal: ⋂ ij ∈ s.sigma fun x => Finset.univ, f ij = ⋂ i ∈ s, ⋂ j, f ⟨i, j⟩

full_name: Set.biInter_finsetSigma_univ'
code: lemma Set.biInter_finsetSigma_univ' (s : Finset ι) (f : Π i, κ i → Set α) :
    ⋂ i ∈ s, ⋂ j, f i j = ⋂ ij ∈ s.sigma fun _ ↦ Finset.univ, f ij.1 ij.2 
goal: ⋂ i ∈ s, ⋂ j, f i j = ⋂ ij ∈ s.sigma fun x => Finset.univ, f ij.fst ij.snd

full_name: Sigma.instFintype
code: instance Sigma.instFintype : Fintype (Σ i, κ i) 
goal: Fintype ((i : ι) × κ i)

full_name: PSigma.instFintype
code: instance PSigma.instFintype : Fintype (Σ' i, κ i) 
goal: Fintype ((i : ι) ×' κ i)

full_name: Finset.univ_sigma_univ
code: @[simp] lemma Finset.univ_sigma_univ : univ.sigma (fun _ ↦ univ) = (univ : Finset (Σ i, κ i)) 
goal: (Finset.univ.sigma fun x => Finset.univ) = Finset.univ
File: Mathlib/Data/Fin/SuccPred.lean

full_name: Fin.instSuccOrder
code: instance : ∀ {n : ℕ}, SuccOrder (Fin n)
  
goal: SuccOrder (Fin n)

full_name: Fin.succ_eq
code: @[simp]
theorem succ_eq {n : ℕ} : SuccOrder.succ = fun a => if a < Fin.last n then a + 1 else a 
goal: SuccOrder.succ = fun a => if a < Fin.last n then a + 1 else a

full_name: Fin.succ_apply
code: @[simp]
theorem succ_apply {n : ℕ} (a) : SuccOrder.succ a = if a < Fin.last n then a + 1 else a 
goal: SuccOrder.succ a = if a < Fin.last n then a + 1 else a

full_name: Fin.instPredOrder
code: instance : ∀ {n : ℕ}, PredOrder (Fin n)
  
goal: PredOrder (Fin n)

full_name: Fin.pred_eq
code: @[simp]
theorem pred_eq {n} : PredOrder.pred = fun a : Fin (n + 1) => if a = 0 then 0 else a - 1 
goal: PredOrder.pred = fun a => if a = 0 then 0 else a - 1

full_name: Fin.pred_apply
code: @[simp]
theorem pred_apply {n : ℕ} (a : Fin (n + 1)) : PredOrder.pred a = if a = 0 then 0 else a - 1 
goal: PredOrder.pred a = if a = 0 then 0 else a - 1
File: Mathlib/Data/PNat/Find.lean

full_name: PNat.decidablePredExistsNat
code: instance decidablePredExistsNat : DecidablePred fun n' : ℕ => ∃ (n : ℕ+) (_ : n' = n), p n 
goal: DecidablePred fun n' => ∃ n, ∃ (_ : n' = ↑n), p n

full_name: PNat.findX
code: /-- The `PNat` version of `Nat.findX` -/
protected def findX : { n // p n ∧ ∀ m : ℕ+, m < n → ¬p m } 
goal: { n // p n ∧ ∀ m < n, ¬p m }

full_name: PNat.find
code: /-- If `p` is a (decidable) predicate on `ℕ+` and `hp : ∃ (n : ℕ+), p n` is a proof that
there exists some positive natural number satisfying `p`, then `PNat.find hp` is the
smallest positive natural number satisfying `p`. Note that `PNat.find` is protected,
meaning that you can't just write `find`, even if the `PNat` namespace is open.

The API for `PNat.find` is:

* `PNat.find_spec` is the proof that `PNat.find hp` satisfies `p`.
* `PNat.find_min` is the proof that if `m < PNat.find hp` then `m` does not satisfy `p`.
* `PNat.find_min'` is the proof that if `m` does satisfy `p` then `PNat.find hp ≤ m`.
-/
protected def find : ℕ+ 
goal: ℕ+

full_name: PNat.find_spec
code: protected theorem find_spec : p (PNat.find h) 
goal: p (PNat.find h)

full_name: PNat.find_min
code: protected theorem find_min : ∀ {m : ℕ+}, m < PNat.find h → ¬p m 
goal: m < PNat.find h → ¬p m

full_name: PNat.find_min'
code: protected theorem find_min' {m : ℕ+} (hm : p m) : PNat.find h ≤ m 
goal: PNat.find h ≤ m

full_name: PNat.find_eq_iff
code: theorem find_eq_iff : PNat.find h = m ↔ p m ∧ ∀ n < m, ¬p n 
goal: PNat.find h = m ↔ p m ∧ ∀ n < m, ¬p n

full_name: PNat.find_lt_iff
code: @[simp]
theorem find_lt_iff (n : ℕ+) : PNat.find h < n ↔ ∃ m < n, p m 
goal: PNat.find h < n ↔ ∃ m < n, p m

full_name: PNat.find_le_iff
code: @[simp]
theorem find_le_iff (n : ℕ+) : PNat.find h ≤ n ↔ ∃ m ≤ n, p m 
goal: PNat.find h ≤ n ↔ ∃ m ≤ n, p m

full_name: PNat.le_find_iff
code: @[simp]
theorem le_find_iff (n : ℕ+) : n ≤ PNat.find h ↔ ∀ m < n, ¬p m 
goal: n ≤ PNat.find h ↔ ∀ m < n, ¬p m

full_name: PNat.lt_find_iff
code: @[simp]
theorem lt_find_iff (n : ℕ+) : n < PNat.find h ↔ ∀ m ≤ n, ¬p m 
goal: n < PNat.find h ↔ ∀ m ≤ n, ¬p m

full_name: PNat.find_eq_one
code: @[simp]
theorem find_eq_one : PNat.find h = 1 ↔ p 1 
goal: PNat.find h = 1 ↔ p 1

full_name: PNat.one_le_find
code: theorem one_le_find : 1 < PNat.find h ↔ ¬p 1 
goal: 1 < PNat.find h ↔ ¬p 1

full_name: PNat.find_mono
code: theorem find_mono (h : ∀ n, q n → p n) {hp : ∃ n, p n} {hq : ∃ n, q n} :
    PNat.find hp ≤ PNat.find hq 
goal: PNat.find hp ≤ PNat.find hq

full_name: PNat.find_le
code: theorem find_le {h : ∃ n, p n} (hn : p n) : PNat.find h ≤ n 
goal: PNat.find h ≤ n

full_name: PNat.find_comp_succ
code: theorem find_comp_succ (h : ∃ n, p n) (h₂ : ∃ n, p (n + 1)) (h1 : ¬p 1) :
    PNat.find h = PNat.find h₂ + 1 
goal: PNat.find h = PNat.find h₂ + 1
File: Mathlib/Data/Fin/FlagRange.lean

full_name: IsMaxChain.range_fin_of_covBy
code: /-- Let `f : Fin (n + 1) → α` be an `(n + 1)`-tuple `(f₀, …, fₙ)` such that
- `f₀ = ⊥` and `fₙ = ⊤`;
- `fₖ₊₁` weakly covers `fₖ` for all `0 ≤ k < n`;
  this means that `fₖ ≤ fₖ₊₁` and there is no `c` such that `fₖ<c<fₖ₊₁`.
Then the range of `f` is a maximal chain. -/
theorem IsMaxChain.range_fin_of_covBy (h0 : f 0 = ⊥) (hlast : f (.last n) = ⊤)
    (hcovBy : ∀ k : Fin n, f k.castSucc ⩿ f k.succ) :
    IsMaxChain (· ≤ ·) (range f) 
goal: IsMaxChain (fun x x_1 => x ≤ x_1) (Set.range f)

full_name: Flag.rangeFin_carrier
code: /-- Let `f : Fin (n + 1) → α` be an `(n + 1)`-tuple `(f₀, …, fₙ)` such that
- `f₀ = ⊥` and `fₙ = ⊤`;
- `fₖ₊₁` weakly covers `fₖ` for all `0 ≤ k < n`;
  this means that `fₖ ≤ fₖ₊₁` and there is no `c` such that `fₖ<c<fₖ₊₁`.
Then the range of `f` is a `Flag α`. -/
@[simps]
def Flag.rangeFin (f : Fin (n + 1) → α) (h0 : f 0 = ⊥) (hlast : f (.last n) = ⊤)
    (hcovBy : ∀ k : Fin n, f k.castSucc ⩿ f k.succ) : Flag α 
goal: ↑(Flag.rangeFin f h0 hlast hcovBy) = Set.range f

full_name: Flag.rangeFin
code: /-- Let `f : Fin (n + 1) → α` be an `(n + 1)`-tuple `(f₀, …, fₙ)` such that
- `f₀ = ⊥` and `fₙ = ⊤`;
- `fₖ₊₁` weakly covers `fₖ` for all `0 ≤ k < n`;
  this means that `fₖ ≤ fₖ₊₁` and there is no `c` such that `fₖ<c<fₖ₊₁`.
Then the range of `f` is a `Flag α`. -/
@[simps]
def Flag.rangeFin (f : Fin (n + 1) → α) (h0 : f 0 = ⊥) (hlast : f (.last n) = ⊤)
    (hcovBy : ∀ k : Fin n, f k.castSucc ⩿ f k.succ) : Flag α 
goal: Flag α

full_name: Flag.mem_rangeFin
code: @[simp] theorem Flag.mem_rangeFin {x h0 hlast hcovBy} :
    x ∈ rangeFin f h0 hlast hcovBy ↔ ∃ k, f k = x 
goal: x ∈ Flag.rangeFin f h0 hlast hcovBy ↔ ∃ k, f k = x
File: Mathlib/Data/Fin/Tuple/Finset.lean

full_name: Fin.mem_piFinset_succ
code: lemma mem_piFinset_succ {x : ∀ i, α i} {s : ∀ i, Finset (α i)} :
    x ∈ piFinset s ↔ x 0 ∈ s 0 ∧ tail x ∈ piFinset (tail s) 
goal: x ∈ Fintype.piFinset s ↔ x 0 ∈ s 0 ∧ Fin.tail x ∈ Fintype.piFinset (Fin.tail s)

full_name: Fin.mem_piFinset_succ'
code: lemma mem_piFinset_succ' {x : ∀ i, α i} {s : ∀ i, Finset (α i)} :
    x ∈ piFinset s ↔ init x ∈ piFinset (init s) ∧ x (last n) ∈ s (last n) 
goal: x ∈ Fintype.piFinset s ↔ Fin.init x ∈ Fintype.piFinset (Fin.init s) ∧ x (Fin.last n) ∈ s (Fin.last n)

full_name: Fin.cons_mem_piFinset_cons
code: lemma cons_mem_piFinset_cons {x₀ : α 0} {x : ∀ i : Fin n, α i.succ}
    {s₀ : Finset (α 0)} {s : ∀ i : Fin n, Finset (α i.succ)} :
    cons x₀ x ∈ piFinset (cons s₀ s) ↔ x₀ ∈ s₀ ∧ x ∈ piFinset s 
goal: Fin.cons x₀ x ∈ Fintype.piFinset (Fin.cons s₀ s) ↔ x₀ ∈ s₀ ∧ x ∈ Fintype.piFinset s

full_name: Fin.snoc_mem_piFinset_snoc
code: lemma snoc_mem_piFinset_snoc {x : ∀ i : Fin n, α i.castSucc} {xₙ : α (.last n)}
    {s : ∀ i : Fin n, Finset (α i.castSucc)} {sₙ : Finset (α $ .last n)} :
    snoc x xₙ ∈ piFinset (snoc s sₙ) ↔ x ∈ piFinset s ∧ xₙ ∈ sₙ 
goal: Fin.snoc x xₙ ∈ Fintype.piFinset (Fin.snoc s sₙ) ↔ x ∈ Fintype.piFinset s ∧ xₙ ∈ sₙ
File: Mathlib/Data/Fin/Tuple/BubbleSortInduction.lean

full_name: Tuple.bubble_sort_induction'
code: /-- *Bubble sort induction*: Prove that the sorted version of `f` has some property `P`
if `f` satisfies `P` and `P` is preserved on permutations of `f` when swapping two
antitone values. -/
theorem bubble_sort_induction' {n : ℕ} {α : Type*} [LinearOrder α] {f : Fin n → α}
    {P : (Fin n → α) → Prop} (hf : P f)
    (h : ∀ (σ : Equiv.Perm (Fin n)) (i j : Fin n),
      i < j → (f ∘ σ) j < (f ∘ σ) i → P (f ∘ σ) → P (f ∘ σ ∘ Equiv.swap i j)) :
    P (f ∘ sort f) 
goal: P (f ∘ ⇑(Tuple.sort f))

full_name: Tuple.bubble_sort_induction
code: /-- *Bubble sort induction*: Prove that the sorted version of `f` has some property `P`
if `f` satisfies `P` and `P` is preserved when swapping two antitone values. -/
theorem bubble_sort_induction {n : ℕ} {α : Type*} [LinearOrder α] {f : Fin n → α}
    {P : (Fin n → α) → Prop} (hf : P f)
    (h : ∀ (g : Fin n → α) (i j : Fin n), i < j → g j < g i → P g → P (g ∘ Equiv.swap i j)) :
    P (f ∘ sort f) 
goal: P (f ∘ ⇑(Tuple.sort f))
File: Mathlib/Data/Fin/Tuple/Reflection.lean

full_name: FinVec.seq
code: /-- Evaluate `FinVec.seq f v = ![(f 0) (v 0), (f 1) (v 1), ...]` -/
def seq : ∀ {m}, (Fin m → α → β) → (Fin m → α) → Fin m → β
  
goal: (Fin m → α → β) → (Fin m → α) → Fin m → β

full_name: FinVec.seq_eq
code: @[simp]
theorem seq_eq : ∀ {m} (f : Fin m → α → β) (v : Fin m → α), seq f v = fun i => f i (v i)
  
goal: FinVec.seq f v = fun i => f i (v i)

full_name: FinVec.map
code: /-- `FinVec.map f v = ![f (v 0), f (v 1), ...]` -/
def map (f : α → β) {m} : (Fin m → α) → Fin m → β 
goal: (Fin m → α) → Fin m → β

full_name: FinVec.map_eq
code: /-- This can be use to prove
```lean
example {f : α → β} (a₁ a₂ : α) : f ∘ ![a₁, a₂] = ![f a₁, f a₂] :=
  (map_eq _ _).symm
```
-/
@[simp]
theorem map_eq (f : α → β) {m} (v : Fin m → α) : map f v = f ∘ v 
goal: FinVec.map f v = f ∘ v

full_name: FinVec.etaExpand
code: /-- Expand `v` to `![v 0, v 1, ...]` -/
def etaExpand {m} (v : Fin m → α) : Fin m → α 
goal: Fin m → α

full_name: FinVec.etaExpand_eq
code: /-- This can be use to prove
```lean
example (a : Fin 2 → α) : a = ![a 0, a 1] :=
  (etaExpand_eq _).symm
```
-/
@[simp]
theorem etaExpand_eq {m} (v : Fin m → α) : etaExpand v = v 
goal: FinVec.etaExpand v = v

full_name: FinVec.Forall
code: /-- `∀` with better defeq for `∀ x : Fin m → α, P x`. -/
def Forall : ∀ {m} (_ : (Fin m → α) → Prop), Prop
  
goal: ((Fin m → α) → Prop) → Prop

full_name: FinVec.forall_iff
code: /-- This can be use to prove
```lean
example (P : (Fin 2 → α) → Prop) : (∀ f, P f) ↔ ∀ a₀ a₁, P ![a₀, a₁] :=
  (forall_iff _).symm
```
-/
@[simp]
theorem forall_iff : ∀ {m} (P : (Fin m → α) → Prop), Forall P ↔ ∀ x, P x
  
goal: FinVec.Forall P ↔ ∀ (x : Fin m → α), P x

full_name: FinVec.Exists
code: /-- `∃` with better defeq for `∃ x : Fin m → α, P x`. -/
def Exists : ∀ {m} (_ : (Fin m → α) → Prop), Prop
  
goal: ((Fin m → α) → Prop) → Prop

full_name: FinVec.exists_iff
code: /-- This can be use to prove
```lean
example (P : (Fin 2 → α) → Prop) : (∃ f, P f) ↔ ∃ a₀ a₁, P ![a₀, a₁] :=
  (exists_iff _).symm
```
-/
theorem exists_iff : ∀ {m} (P : (Fin m → α) → Prop), Exists P ↔ ∃ x, P x
  
goal: FinVec.Exists P ↔ ∃ x, P x

full_name: FinVec.sum
code: /-- `Finset.univ.sum` with better defeq for `Fin`. -/
def sum [Add α] [Zero α] : ∀ {m} (_ : Fin m → α), α
  
goal: (Fin m → α) → α

full_name: FinVec.sum_eq
code: /-- This can be used to prove
```lean
example [AddCommMonoid α] (a : Fin 3 → α) : ∑ i, a i = a 0 + a 1 + a 2 :=
  (sum_eq _).symm
```
-/
@[simp]
theorem sum_eq [AddCommMonoid α] : ∀ {m} (a : Fin m → α), sum a = ∑ i, a i
  
goal: FinVec.sum a = ∑ i : Fin m, a i
File: Mathlib/Data/Finite/Set.lean

full_name: Finite.Set.finite_of_finite_image
code: theorem Finite.Set.finite_of_finite_image (s : Set α) {f : α → β} (h : s.InjOn f)
    [Finite (f '' s)] : Finite s 
goal: Finite ↑s

full_name: Finite.of_injective_finite_range
code: theorem Finite.of_injective_finite_range {f : ι → α} (hf : Function.Injective f)
    [Finite (range f)] : Finite ι 
goal: Finite ι
File: Mathlib/Data/Finite/Basic.lean

full_name: Finite.of_subsingleton
code: instance (priority := 100) of_subsingleton {α : Sort*} [Subsingleton α] : Finite α 
goal: Finite α

full_name: Finite.prop
code: instance prop (p : Prop) : Finite p 
goal: Finite p

full_name: Finite.instProd
code: instance [Finite α] [Finite β] : Finite (α × β) 
goal: Finite (α × β)

full_name: Finite.instPProd
code: instance {α β : Sort*} [Finite α] [Finite β] : Finite (PProd α β) 
goal: Finite (PProd α β)

full_name: Finite.prod_left
code: theorem prod_left (β) [Finite (α × β)] [Nonempty β] : Finite α 
goal: Finite α

full_name: Finite.prod_right
code: theorem prod_right (α) [Finite (α × β)] [Nonempty α] : Finite β 
goal: Finite β

full_name: Finite.instSum
code: instance [Finite α] [Finite β] : Finite (α ⊕ β) 
goal: Finite (α ⊕ β)

full_name: Finite.sum_left
code: theorem sum_left (β) [Finite (α ⊕ β)] : Finite α 
goal: Finite α

full_name: Finite.sum_right
code: theorem sum_right (α) [Finite (α ⊕ β)] : Finite β 
goal: Finite β

full_name: Finite.instSigma
code: instance {β : α → Type*} [Finite α] [∀ a, Finite (β a)] : Finite (Σa, β a) 
goal: Finite ((a : α) × β a)

full_name: Finite.instPSigma
code: instance {ι : Sort*} {π : ι → Sort*} [Finite ι] [∀ i, Finite (π i)] : Finite (Σ'i, π i) 
goal: Finite ((i : ι) ×' π i)

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

full_name: Pi.finite
code: instance Pi.finite {α : Sort*} {β : α → Sort*} [Finite α] [∀ a, Finite (β a)] :
    Finite (∀ a, β a) 
goal: Finite ((a : α) → β a)

full_name: Vector.finite
code: instance Vector.finite {α : Type*} [Finite α] {n : ℕ} : Finite (Vector α n) 
goal: Finite (Mathlib.Vector α n)

full_name: Quot.finite
code: instance Quot.finite {α : Sort*} [Finite α] (r : α → α → Prop) : Finite (Quot r) 
goal: Finite (Quot r)

full_name: Quotient.finite
code: instance Quotient.finite {α : Sort*} [Finite α] (s : Setoid α) : Finite (Quotient s) 
goal: Finite (Quotient s)

full_name: Function.Embedding.finite
code: instance Function.Embedding.finite {α β : Sort*} [Finite β] : Finite (α ↪ β) 
goal: Finite (α ↪ β)

full_name: Equiv.finite_right
code: instance Equiv.finite_right {α β : Sort*} [Finite β] : Finite (α ≃ β) 
goal: Finite (α ≃ β)

full_name: Equiv.finite_left
code: instance Equiv.finite_left {α β : Sort*} [Finite α] : Finite (α ≃ β) 
goal: Finite (α ≃ β)

full_name: instFiniteSym
code: instance [Finite α] {n : ℕ} : Finite (Sym α n) 
goal: Finite (Sym α n)
File: Mathlib/Data/BitVec.lean

full_name: BitVec.toNat_injective
code: theorem toNat_injective {n : Nat} : Function.Injective (BitVec.toNat : BitVec n → _)
  
goal: Function.Injective BitVec.toNat

full_name: BitVec.toFin_injective
code: theorem toFin_injective {n : Nat} : Function.Injective (toFin : BitVec n → _)
  
goal: Function.Injective BitVec.toFin

full_name: BitVec.instSMulNat
code: instance : SMul ℕ (BitVec w) 
goal: SMul ℕ (BitVec w)

full_name: BitVec.instSMulInt
code: instance : SMul ℤ (BitVec w) 
goal: SMul ℤ (BitVec w)

full_name: BitVec.instPowNat_mathlib
code: instance : Pow (BitVec w) ℕ  
goal: Pow (BitVec w) ℕ

full_name: BitVec.toFin_nsmul
code: lemma toFin_nsmul (n : ℕ) (x : BitVec w)  : toFin (n • x) = n • x.toFin 
goal: (n • x).toFin = n • x.toFin

full_name: BitVec.toFin_zsmul
code: lemma toFin_zsmul (z : ℤ) (x : BitVec w)  : toFin (z • x) = z • x.toFin 
goal: (z • x).toFin = z • x.toFin

full_name: BitVec.toFin_pow
code: lemma toFin_pow (x : BitVec w) (n : ℕ)    : toFin (x ^ n) = x.toFin ^ n 
goal: (x ^ n).toFin = x.toFin ^ n

full_name: BitVec.instCommSemiring
code: instance : CommSemiring (BitVec w) 
goal: CommSemiring (BitVec w)
File: Mathlib/Data/Nat/Cast/Order/Field.lean

full_name: Nat.cast_inv_le_one
code: lemma cast_inv_le_one : ∀ n : ℕ, (n⁻¹ : α) ≤ 1
  
goal: (↑n)⁻¹ ≤ 1

full_name: Nat.cast_div_le
code: /-- Natural division is always less than division in the field. -/
theorem cast_div_le {m n : ℕ} : ((m / n : ℕ) : α) ≤ m / n 
goal: ↑(m / n) ≤ ↑m / ↑n

full_name: Nat.inv_pos_of_nat
code: theorem inv_pos_of_nat {n : ℕ} : 0 < ((n : α) + 1)⁻¹ 
goal: 0 < (↑n + 1)⁻¹

full_name: Nat.one_div_pos_of_nat
code: theorem one_div_pos_of_nat {n : ℕ} : 0 < 1 / ((n : α) + 1) 
goal: 0 < 1 / (↑n + 1)

full_name: Nat.one_div_le_one_div
code: theorem one_div_le_one_div {n m : ℕ} (h : n ≤ m) : 1 / ((m : α) + 1) ≤ 1 / ((n : α) + 1) 
goal: 1 / (↑m + 1) ≤ 1 / (↑n + 1)

full_name: Nat.one_div_lt_one_div
code: theorem one_div_lt_one_div {n m : ℕ} (h : n < m) : 1 / ((m : α) + 1) < 1 / ((n : α) + 1) 
goal: 1 / (↑m + 1) < 1 / (↑n + 1)
File: Mathlib/Data/Nat/Cast/Field.lean

full_name: Nat.cast_div
code: @[simp]
theorem cast_div [DivisionSemiring α] {m n : ℕ} (n_dvd : n ∣ m) (hn : (n : α) ≠ 0) :
    ((m / n : ℕ) : α) = m / n 
goal: ↑(m / n) = ↑m / ↑n

full_name: Nat.cast_div_div_div_cancel_right
code: theorem cast_div_div_div_cancel_right [DivisionSemiring α] [CharZero α] {m n d : ℕ}
    (hn : d ∣ n) (hm : d ∣ m) :
    (↑(m / d) : α) / (↑(n / d) : α) = (m : α) / n 
goal: ↑(m / d) / ↑(n / d) = ↑m / ↑n