ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Data/List/FinRange.lean

full_name: List.map_coe_finRange
code: @[simp]
theorem map_coe_finRange (n : ℕ) : ((finRange n) : List (Fin n)).map (Fin.val) = List.range n 
goal: List.map Fin.val (List.finRange n) = List.range n

full_name: List.finRange_succ_eq_map
code: theorem finRange_succ_eq_map (n : ℕ) : finRange n.succ = 0 :: (finRange n).map Fin.succ 
goal: List.finRange n.succ = 0 :: List.map Fin.succ (List.finRange n)

full_name: List.finRange_succ
code: theorem finRange_succ (n : ℕ) :
    finRange n.succ = (finRange n |>.map Fin.castSucc |>.concat (.last _)) 
goal: List.finRange n.succ = (List.map Fin.castSucc (List.finRange n)).concat (Fin.last n)

full_name: List.ofFn_eq_pmap
code: theorem ofFn_eq_pmap {n} {f : Fin n → α} :
    ofFn f = pmap (fun i hi => f ⟨i, hi⟩) (range n) fun _ => mem_range.1 
goal: List.ofFn f = List.pmap (fun i hi => f ⟨i, hi⟩) (List.range n) ⋯

full_name: List.ofFn_id
code: theorem ofFn_id (n) : ofFn id = finRange n 
goal: List.ofFn id = List.finRange n

full_name: List.ofFn_eq_map
code: theorem ofFn_eq_map {n} {f : Fin n → α} : ofFn f = (finRange n).map f 
goal: List.ofFn f = List.map f (List.finRange n)

full_name: List.nodup_ofFn_ofInjective
code: theorem nodup_ofFn_ofInjective {n} {f : Fin n → α} (hf : Function.Injective f) :
    Nodup (ofFn f) 
goal: (List.ofFn f).Nodup

full_name: List.nodup_ofFn
code: theorem nodup_ofFn {n} {f : Fin n → α} : Nodup (ofFn f) ↔ Function.Injective f 
goal: (List.ofFn f).Nodup ↔ Function.Injective f

full_name: Equiv.Perm.map_finRange_perm
code: theorem Equiv.Perm.map_finRange_perm {n : ℕ} (σ : Equiv.Perm (Fin n)) :
    map σ (finRange n) ~ finRange n 
goal: List.map (⇑σ) (List.finRange n) ~ List.finRange n

full_name: Equiv.Perm.ofFn_comp_perm
code: /-- The list obtained from a permutation of a tuple `f` is permutation equivalent to
the list obtained from `f`. -/
theorem Equiv.Perm.ofFn_comp_perm {n : ℕ} {α : Type u} (σ : Equiv.Perm (Fin n)) (f : Fin n → α) :
    ofFn (f ∘ σ) ~ ofFn f 
goal: List.ofFn (f ∘ ⇑σ) ~ List.ofFn f
File: Mathlib/Data/List/TFAE.lean

full_name: List.TFAE
code: /-- TFAE: The Following (propositions) Are Equivalent.

The `tfae_have` and `tfae_finish` tactics can be useful in proofs with `TFAE` goals.
-/
def TFAE (l : List Prop) : Prop 
goal: Prop

full_name: List.tfae_nil
code: theorem tfae_nil : TFAE [] 
goal: [].TFAE

full_name: List.tfae_singleton
code: @[simp]
theorem tfae_singleton (p) : TFAE [p] 
goal: [p].TFAE

full_name: List.tfae_cons_of_mem
code: theorem tfae_cons_of_mem {a b} {l : List Prop} (h : b ∈ l) : TFAE (a :: l) ↔ (a ↔ b) ∧ TFAE l 
goal: (a :: l).TFAE ↔ (a ↔ b) ∧ l.TFAE

full_name: List.tfae_cons_cons
code: theorem tfae_cons_cons {a b} {l : List Prop} : TFAE (a :: b :: l) ↔ (a ↔ b) ∧ TFAE (b :: l) 
goal: (a :: b :: l).TFAE ↔ (a ↔ b) ∧ (b :: l).TFAE

full_name: List.tfae_cons_self
code: @[simp]
theorem tfae_cons_self {a} {l : List Prop} : TFAE (a :: a :: l) ↔ TFAE (a :: l) 
goal: (a :: a :: l).TFAE ↔ (a :: l).TFAE

full_name: List.tfae_of_forall
code: theorem tfae_of_forall (b : Prop) (l : List Prop) (h : ∀ a ∈ l, a ↔ b) : TFAE l 
goal: l.TFAE

full_name: List.tfae_of_cycle
code: theorem tfae_of_cycle {a b} {l : List Prop} (h_chain : List.Chain (· → ·) a (b :: l))
    (h_last : getLastD l b → a) : TFAE (a :: b :: l) 
goal: (a :: b :: l).TFAE

full_name: List.TFAE.out
code: theorem TFAE.out {l} (h : TFAE l) (n₁ n₂) {a b} (h₁ : List.get? l n₁ = some a := by rfl)
    (h₂ : List.get? l n₂ = some b := by rfl) : a ↔ b 
goal: a ↔ b

full_name: List.forall_tfae
code: /-- If `P₁ x ↔ ... ↔ Pₙ x` for all `x`, then `(∀ x, P₁ x) ↔ ... ↔ (∀ x, Pₙ x)`.
Note: in concrete cases, Lean has trouble finding the list `[P₁, ..., Pₙ]` from the list
`[(∀ x, P₁ x), ..., (∀ x, Pₙ x)]`, but simply providing a list of underscores with the right
length makes it happier.

Example:
```lean
example (P₁ P₂ P₃ : ℕ → Prop) (H : ∀ n, [P₁ n, P₂ n, P₃ n].TFAE) :
    [∀ n, P₁ n, ∀ n, P₂ n, ∀ n, P₃ n].TFAE :=
  forall_tfae [_, _, _] H
```
-/
theorem forall_tfae {α : Type*} (l : List (α → Prop)) (H : ∀ a : α, (l.map (fun p ↦ p a)).TFAE) :
    (l.map (fun p ↦ ∀ a, p a)).TFAE 
goal: (List.map (fun p => ∀ (a : α), p a) l).TFAE

full_name: List.exists_tfae
code: /-- If `P₁ x ↔ ... ↔ Pₙ x` for all `x`, then `(∃ x, P₁ x) ↔ ... ↔ (∃ x, Pₙ x)`.
Note: in concrete cases, Lean has trouble finding the list `[P₁, ..., Pₙ]` from the list
`[(∃ x, P₁ x), ..., (∃ x, Pₙ x)]`, but simply providing a list of underscores with the right
length makes it happier.

Example:
```lean
example (P₁ P₂ P₃ : ℕ → Prop) (H : ∀ n, [P₁ n, P₂ n, P₃ n].TFAE) :
    [∃ n, P₁ n, ∃ n, P₂ n, ∃ n, P₃ n].TFAE :=
  exists_tfae [_, _, _] H
```
-/
theorem exists_tfae {α : Type*} (l : List (α → Prop)) (H : ∀ a : α, (l.map (fun p ↦ p a)).TFAE) :
    (l.map (fun p ↦ ∃ a, p a)).TFAE 
goal: (List.map (fun p => ∃ a, p a) l).TFAE

full_name: List.tfae_not_iff
code: theorem tfae_not_iff {l : List Prop} : TFAE (l.map Not) ↔ TFAE l 
goal: (List.map Not l).TFAE ↔ l.TFAE
File: Mathlib/Data/List/NatAntidiagonal.lean

full_name: List.Nat.antidiagonal
code: /-- The antidiagonal of a natural number `n` is the list of pairs `(i, j)` such that `i + j = n`. -/
def antidiagonal (n : ℕ) : List (ℕ × ℕ) 
goal: List (ℕ × ℕ)

full_name: List.Nat.mem_antidiagonal
code: /-- A pair (i, j) is contained in the antidiagonal of `n` if and only if `i + j = n`. -/
@[simp]
theorem mem_antidiagonal {n : ℕ} {x : ℕ × ℕ} : x ∈ antidiagonal n ↔ x.1 + x.2 = n 
goal: x ∈ List.Nat.antidiagonal n ↔ x.1 + x.2 = n

full_name: List.Nat.length_antidiagonal
code: /-- The length of the antidiagonal of `n` is `n + 1`. -/
@[simp]
theorem length_antidiagonal (n : ℕ) : (antidiagonal n).length = n + 1 
goal: (List.Nat.antidiagonal n).length = n + 1

full_name: List.Nat.antidiagonal_zero
code: /-- The antidiagonal of `0` is the list `[(0, 0)]` -/
@[simp]
theorem antidiagonal_zero : antidiagonal 0 = [(0, 0)] 
goal: List.Nat.antidiagonal 0 = [(0, 0)]

full_name: List.Nat.nodup_antidiagonal
code: /-- The antidiagonal of `n` does not contain duplicate entries. -/
theorem nodup_antidiagonal (n : ℕ) : Nodup (antidiagonal n) 
goal: (List.Nat.antidiagonal n).Nodup

full_name: List.Nat.antidiagonal_succ
code: @[simp]
theorem antidiagonal_succ {n : ℕ} :
    antidiagonal (n + 1) = (0, n + 1) :: (antidiagonal n).map (Prod.map Nat.succ id) 
goal: List.Nat.antidiagonal (n + 1) = (0, n + 1) :: List.map (Prod.map Nat.succ id) (List.Nat.antidiagonal n)

full_name: List.Nat.antidiagonal_succ'
code: theorem antidiagonal_succ' {n : ℕ} :
    antidiagonal (n + 1) = (antidiagonal n).map (Prod.map id Nat.succ) ++ [(n + 1, 0)] 
goal: List.Nat.antidiagonal (n + 1) = List.map (Prod.map id Nat.succ) (List.Nat.antidiagonal n) ++ [(n + 1, 0)]

full_name: List.Nat.antidiagonal_succ_succ'
code: theorem antidiagonal_succ_succ' {n : ℕ} :
    antidiagonal (n + 2) =
      (0, n + 2) :: (antidiagonal n).map (Prod.map Nat.succ Nat.succ) ++ [(n + 2, 0)] 
goal: List.Nat.antidiagonal (n + 2) =
  (0, n + 2) :: List.map (Prod.map Nat.succ Nat.succ) (List.Nat.antidiagonal n) ++ [(n + 2, 0)]

full_name: List.Nat.map_swap_antidiagonal
code: theorem map_swap_antidiagonal {n : ℕ} :
    (antidiagonal n).map Prod.swap = (antidiagonal n).reverse 
goal: List.map Prod.swap (List.Nat.antidiagonal n) = (List.Nat.antidiagonal n).reverse
File: Mathlib/Data/List/EditDistance/Bounds.lean

full_name: suffixLevenshtein_minimum_le_levenshtein_cons
code: theorem suffixLevenshtein_minimum_le_levenshtein_cons (xs : List α) (y ys) :
    (suffixLevenshtein C xs ys).1.minimum ≤ levenshtein C xs (y :: ys) 
goal: (↑(suffixLevenshtein C xs ys)).minimum ≤ ↑(levenshtein C xs (y :: ys))

full_name: le_suffixLevenshtein_cons_minimum
code: theorem le_suffixLevenshtein_cons_minimum (xs : List α) (y ys) :
    (suffixLevenshtein C xs ys).1.minimum ≤ (suffixLevenshtein C xs (y :: ys)).1.minimum 
goal: (↑(suffixLevenshtein C xs ys)).minimum ≤ (↑(suffixLevenshtein C xs (y :: ys))).minimum

full_name: le_suffixLevenshtein_append_minimum
code: theorem le_suffixLevenshtein_append_minimum (xs : List α) (ys₁ ys₂) :
    (suffixLevenshtein C xs ys₂).1.minimum ≤ (suffixLevenshtein C xs (ys₁ ++ ys₂)).1.minimum 
goal: (↑(suffixLevenshtein C xs ys₂)).minimum ≤ (↑(suffixLevenshtein C xs (ys₁ ++ ys₂))).minimum

full_name: suffixLevenshtein_minimum_le_levenshtein_append
code: theorem suffixLevenshtein_minimum_le_levenshtein_append (xs ys₁ ys₂) :
    (suffixLevenshtein C xs ys₂).1.minimum ≤ levenshtein C xs (ys₁ ++ ys₂) 
goal: (↑(suffixLevenshtein C xs ys₂)).minimum ≤ ↑(levenshtein C xs (ys₁ ++ ys₂))

full_name: le_levenshtein_cons
code: theorem le_levenshtein_cons (xs : List α) (y ys) :
    ∃ xs', xs' <:+ xs ∧ levenshtein C xs' ys ≤ levenshtein C xs (y :: ys) 
goal: ∃ xs', xs' <:+ xs ∧ levenshtein C xs' ys ≤ levenshtein C xs (y :: ys)

full_name: le_levenshtein_append
code: theorem le_levenshtein_append (xs : List α) (ys₁ ys₂) :
    ∃ xs', xs' <:+ xs ∧ levenshtein C xs' ys₂ ≤ levenshtein C xs (ys₁ ++ ys₂) 
goal: ∃ xs', xs' <:+ xs ∧ levenshtein C xs' ys₂ ≤ levenshtein C xs (ys₁ ++ ys₂)
File: Mathlib/Data/List/ProdSigma.lean

full_name: List.nil_product
code: @[simp]
theorem nil_product (l : List β) : (@nil α) ×ˢ l = [] 
goal: [] ×ˢ l = []

full_name: List.product_cons
code: @[simp]
theorem product_cons (a : α) (l₁ : List α) (l₂ : List β) :
    (a :: l₁) ×ˢ l₂ = map (fun b => (a, b)) l₂ ++ (l₁ ×ˢ l₂) 
goal: (a :: l₁) ×ˢ l₂ = List.map (fun b => (a, b)) l₂ ++ l₁ ×ˢ l₂

full_name: List.product_nil
code: @[simp]
theorem product_nil : ∀ l : List α, l ×ˢ (@nil β) = []
  
goal: l ×ˢ [] = []

full_name: List.mem_product
code: @[simp]
theorem mem_product {l₁ : List α} {l₂ : List β} {a : α} {b : β} :
    (a, b) ∈ l₁ ×ˢ l₂ ↔ a ∈ l₁ ∧ b ∈ l₂ 
goal: (a, b) ∈ l₁ ×ˢ l₂ ↔ a ∈ l₁ ∧ b ∈ l₂

full_name: List.length_product
code: theorem length_product (l₁ : List α) (l₂ : List β) :
    length (l₁ ×ˢ l₂) = length l₁ * length l₂ 
goal: (l₁ ×ˢ l₂).length = l₁.length * l₂.length

full_name: List.nil_sigma
code: @[simp]
theorem nil_sigma (l : ∀ a, List (σ a)) : (@nil α).sigma l = [] 
goal: [].sigma l = []

full_name: List.sigma_cons
code: @[simp]
theorem sigma_cons (a : α) (l₁ : List α) (l₂ : ∀ a, List (σ a)) :
    (a :: l₁).sigma l₂ = map (Sigma.mk a) (l₂ a) ++ l₁.sigma l₂ 
goal: (a :: l₁).sigma l₂ = List.map (Sigma.mk a) (l₂ a) ++ l₁.sigma l₂

full_name: List.sigma_nil
code: @[simp]
theorem sigma_nil : ∀ l : List α, (l.sigma fun a => @nil (σ a)) = []
  
goal: (l.sigma fun a => []) = []

full_name: List.mem_sigma
code: @[simp]
theorem mem_sigma {l₁ : List α} {l₂ : ∀ a, List (σ a)} {a : α} {b : σ a} :
    Sigma.mk a b ∈ l₁.sigma l₂ ↔ a ∈ l₁ ∧ b ∈ l₂ a 
goal: ⟨a, b⟩ ∈ l₁.sigma l₂ ↔ a ∈ l₁ ∧ b ∈ l₂ a

full_name: List.length_sigma'
code: /-- See `List.length_sigma` for the corresponding statement using `List.sum`. -/
theorem length_sigma' (l₁ : List α) (l₂ : ∀ a, List (σ a)) :
    length (l₁.sigma l₂) = Nat.sum (l₁.map fun a ↦ length (l₂ a)) 
goal: (l₁.sigma l₂).length = Nat.sum (List.map (fun a => (l₂ a).length) l₁)
File: Mathlib/Data/List/Count.lean

full_name: List.length_filter_lt_length_iff_exists
code: theorem length_filter_lt_length_iff_exists (l) :
    length (filter p l) < length l ↔ ∃ x ∈ l, ¬p x 
goal: (List.filter p l).length < l.length ↔ ∃ x, x ∈ l ∧ ¬p x = true

full_name: List.countP_attach
code: lemma countP_attach (l : List α) : l.attach.countP (fun a : {x // x ∈ l} ↦ p a) = l.countP p 
goal: List.countP (fun a => p ↑a) l.attach = List.countP p l

full_name: List.count_map_of_injective
code: @[simp]
theorem count_map_of_injective {β} [DecidableEq α] [DecidableEq β] (l : List α) (f : α → β)
    (hf : Function.Injective f) (x : α) : count (f x) (map f l) = count x l 
goal: List.count (f x) (List.map f l) = List.count x l

full_name: List.count_cons'
code: @[deprecated (since := "2023-08-23")]
theorem count_cons' (a b : α) (l : List α) :
    count a (b :: l) = count a l + if a = b then 1 else 0 
goal: List.count a (b :: l) = List.count a l + if a = b then 1 else 0

full_name: List.count_attach
code: @[simp]
lemma count_attach (a : {x // x ∈ l}) : l.attach.count a = l.count ↑a 
goal: List.count a l.attach = List.count (↑a) l
File: Mathlib/Data/List/Prime.lean

full_name: Prime.dvd_prod_iff
code: /-- Prime `p` divides the product of a list `L` iff it divides some `a ∈ L` -/
theorem Prime.dvd_prod_iff {p : M} {L : List M} (pp : Prime p) : p ∣ L.prod ↔ ∃ a ∈ L, p ∣ a 
goal: p ∣ L.prod ↔ ∃ a ∈ L, p ∣ a

full_name: Prime.not_dvd_prod
code: theorem Prime.not_dvd_prod {p : M} {L : List M} (pp : Prime p) (hL : ∀ a ∈ L, ¬p ∣ a) :
    ¬p ∣ L.prod 
goal: ¬p ∣ L.prod

full_name: mem_list_primes_of_dvd_prod
code: theorem mem_list_primes_of_dvd_prod {p : M} (hp : Prime p) {L : List M} (hL : ∀ q ∈ L, Prime q)
    (hpL : p ∣ L.prod) : p ∈ L 
goal: p ∈ L

full_name: perm_of_prod_eq_prod
code: theorem perm_of_prod_eq_prod :
    ∀ {l₁ l₂ : List M}, l₁.prod = l₂.prod → (∀ p ∈ l₁, Prime p) → (∀ p ∈ l₂, Prime p) → Perm l₁ l₂
  
goal: l₁.prod = l₂.prod → (∀ p ∈ l₁, Prime p) → (∀ p ∈ l₂, Prime p) → l₁ ~ l₂
File: Mathlib/Data/DList/Basic.lean

full_name: Batteries.DList.join
code: /-- Concatenates a list of difference lists to form a single difference list. Similar to
`List.join`. -/
def DList.join {α : Type*} : List (DList α) → DList α
  
goal: List (Batteries.DList α) → Batteries.DList α

full_name: Batteries.DList_singleton
code: @[simp]
theorem DList_singleton {α : Type*} {a : α} : DList.singleton a = DList.lazy_ofList [a] 
goal: Batteries.DList.singleton a = Batteries.DList.lazy_ofList { fn := fun x => [a] }

full_name: Batteries.DList_lazy
code: @[simp]
theorem DList_lazy {α : Type*} {l : List α} : DList.lazy_ofList l = Batteries.DList.ofList l 
goal: Batteries.DList.lazy_ofList { fn := fun x => l } = Batteries.DList.ofList l
File: Mathlib/Data/DList/Defs.lean

full_name: Batteries.DList.lazy_ofList
code: /-- Convert a lazily-evaluated `List` to a `DList` -/
def lazy_ofList (l : Thunk (List α)) : DList α 
goal: Batteries.DList α

full_name: Batteries.DList.toList_ofList
code: theorem toList_ofList (l : List α) : DList.toList (DList.ofList l) = l 
goal: (Batteries.DList.ofList l).toList = l

full_name: Batteries.DList.ofList_toList
code: theorem ofList_toList (l : DList α) : DList.ofList (DList.toList l) = l 
goal: Batteries.DList.ofList l.toList = l

full_name: Batteries.DList.toList_empty
code: theorem toList_empty : toList (@empty α) = [] 
goal: Batteries.DList.empty.toList = []

full_name: Batteries.DList.toList_singleton
code: theorem toList_singleton (x : α) : toList (singleton x) = [x] 
goal: (Batteries.DList.singleton x).toList = [x]

full_name: Batteries.DList.toList_append
code: theorem toList_append (l₁ l₂ : DList α) : toList (l₁ ++ l₂) = toList l₁ ++ toList l₂ 
goal: (l₁ ++ l₂).toList = l₁.toList ++ l₂.toList

full_name: Batteries.DList.toList_cons
code: theorem toList_cons (x : α) (l : DList α) : toList (cons x l) = x :: toList l 
goal: (Batteries.DList.cons x l).toList = x :: l.toList

full_name: Batteries.DList.toList_push
code: theorem toList_push (x : α) (l : DList α) : toList (push l x) = toList l ++ [x] 
goal: (l.push x).toList = l.toList ++ [x]
File: Mathlib/Data/DList/Instances.lean

full_name: Batteries.DList.listEquivDList
code: /-- The natural equivalence between lists and difference lists, using
`DList.ofList` and `DList.toList`. -/
def DList.listEquivDList : List α ≃ DList α 
goal: List α ≃ Batteries.DList α

full_name: Batteries.instTraversableDList
code: instance : Traversable DList 
goal: Traversable Batteries.DList

full_name: Batteries.instLawfulTraversableDList
code: instance : LawfulTraversable DList 
goal: LawfulTraversable Batteries.DList

full_name: Batteries.instInhabitedDList_mathlib
code: instance {α} : Inhabited (DList α) 
goal: Inhabited (Batteries.DList α)
File: Mathlib/Data/List/Pairwise.lean

full_name: List.Pairwise.forall_of_forall
code: theorem Pairwise.forall_of_forall (H : Symmetric R) (H₁ : ∀ x ∈ l, R x x) (H₂ : l.Pairwise R) :
    ∀ ⦃x⦄, x ∈ l → ∀ ⦃y⦄, y ∈ l → R x y 
goal: x ∈ l → ∀ ⦃y : α⦄, y ∈ l → R x y

full_name: List.Pairwise.forall
code: theorem Pairwise.forall (hR : Symmetric R) (hl : l.Pairwise R) :
    ∀ ⦃a⦄, a ∈ l → ∀ ⦃b⦄, b ∈ l → a ≠ b → R a b 
goal: a ∈ l → ∀ ⦃b : α⦄, b ∈ l → a ≠ b → R a b

full_name: List.Pairwise.set_pairwise
code: theorem Pairwise.set_pairwise (hl : Pairwise R l) (hr : Symmetric R) : { x | x ∈ l }.Pairwise R 
goal: {x | x ∈ l}.Pairwise R

full_name: List.pairwise_map'
code: @[deprecated (since := "2024-02-25")] theorem pairwise_map' (f : β → α) :
    ∀ {l : List β}, Pairwise R (map f l) ↔ Pairwise (fun a b : β => R (f a) (f b)) l
  
goal: List.Pairwise R (List.map f l) ↔ List.Pairwise (fun a b => R (f a) (f b)) l

full_name: List.pairwise_pmap
code: theorem pairwise_pmap {p : β → Prop} {f : ∀ b, p b → α} {l : List β} (h : ∀ x ∈ l, p x) :
    Pairwise R (l.pmap f h) ↔
      Pairwise (fun b₁ b₂ => ∀ (h₁ : p b₁) (h₂ : p b₂), R (f b₁ h₁) (f b₂ h₂)) l 
goal: List.Pairwise R (List.pmap f l h) ↔ List.Pairwise (fun b₁ b₂ => ∀ (h₁ : p b₁) (h₂ : p b₂), R (f b₁ h₁) (f b₂ h₂)) l

full_name: List.Pairwise.pmap
code: theorem Pairwise.pmap {l : List α} (hl : Pairwise R l) {p : α → Prop} {f : ∀ a, p a → β}
    (h : ∀ x ∈ l, p x) {S : β → β → Prop}
    (hS : ∀ ⦃x⦄ (hx : p x) ⦃y⦄ (hy : p y), R x y → S (f x hx) (f y hy)) :
    Pairwise S (l.pmap f h) 
goal: List.Pairwise S (List.pmap f l h)

full_name: List.pairwise_of_forall_mem_list
code: theorem pairwise_of_forall_mem_list {l : List α} {r : α → α → Prop} (h : ∀ a ∈ l, ∀ b ∈ l, r a b) :
    l.Pairwise r 
goal: List.Pairwise r l

full_name: List.pairwise_of_reflexive_of_forall_ne
code: theorem pairwise_of_reflexive_of_forall_ne {l : List α} {r : α → α → Prop} (hr : Reflexive r)
    (h : ∀ a ∈ l, ∀ b ∈ l, a ≠ b → r a b) : l.Pairwise r 
goal: List.Pairwise r l

full_name: List.pairwise_iff_nthLe
code: @[deprecated pairwise_iff_get (since := "2023-01-10")]
theorem pairwise_iff_nthLe {R} {l : List α} : Pairwise R l ↔
    ∀ (i j) (h₁ : j < length l) (h₂ : i < j), R (nthLe l i (lt_trans h₂ h₁)) (nthLe l j h₁) 
goal: List.Pairwise R l ↔ ∀ (i j : ℕ) (h₁ : j < l.length) (h₂ : i < j), R (l.nthLe i ⋯) (l.nthLe j h₁)
File: Mathlib/Data/Countable/Basic.lean

full_name: instCountableInt
code: instance : Countable ℤ 
goal: Countable ℤ

full_name: countable_iff_nonempty_embedding
code: theorem countable_iff_nonempty_embedding : Countable α ↔ Nonempty (α ↪ ℕ) 
goal: Countable α ↔ Nonempty (α ↪ ℕ)

full_name: uncountable_iff_isEmpty_embedding
code: theorem uncountable_iff_isEmpty_embedding : Uncountable α ↔ IsEmpty (α ↪ ℕ) 
goal: Uncountable α ↔ IsEmpty (α ↪ ℕ)

full_name: nonempty_embedding_nat
code: theorem nonempty_embedding_nat (α) [Countable α] : Nonempty (α ↪ ℕ) 
goal: Nonempty (α ↪ ℕ)

full_name: Function.Embedding.countable
code: protected theorem Function.Embedding.countable [Countable β] (f : α ↪ β) : Countable α 
goal: Countable α

full_name: Function.Embedding.uncountable
code: protected lemma Function.Embedding.uncountable [Uncountable α] (f : α ↪ β) : Uncountable β 
goal: Uncountable β

full_name: instCountableSum
code: instance [Countable α] [Countable β] : Countable (α ⊕ β) 
goal: Countable (α ⊕ β)

full_name: Sum.uncountable_inl
code: instance Sum.uncountable_inl [Uncountable α] : Uncountable (α ⊕ β) 
goal: Uncountable (α ⊕ β)

full_name: Sum.uncountable_inr
code: instance Sum.uncountable_inr [Uncountable β] : Uncountable (α ⊕ β) 
goal: Uncountable (α ⊕ β)

full_name: instCountableOption
code: instance [Countable α] : Countable (Option α) 
goal: Countable (Option α)

full_name: Option.instUncountable
code: instance Option.instUncountable [Uncountable α] : Uncountable (Option α) 
goal: Uncountable (Option α)

full_name: instCountableProd
code: instance [Countable α] [Countable β] : Countable (α × β) 
goal: Countable (α × β)

full_name: instUncountableProdOfNonempty
code: instance [Uncountable α] [Nonempty β] : Uncountable (α × β) 
goal: Uncountable (α × β)

full_name: instUncountableProdOfNonempty_1
code: instance [Nonempty α] [Uncountable β] : Uncountable (α × β) 
goal: Uncountable (α × β)

full_name: instCountableSigma
code: instance [Countable α] [∀ a, Countable (π a)] : Countable (Sigma π) 
goal: Countable (Sigma π)

full_name: Sigma.uncountable
code: lemma Sigma.uncountable (a : α) [Uncountable (π a)] : Uncountable (Sigma π) 
goal: Uncountable (Sigma π)

full_name: instUncountableSigmaOfNonempty
code: instance [Nonempty α] [∀ a, Uncountable (π a)] : Uncountable (Sigma π) 
goal: Uncountable (Sigma π)

full_name: SetCoe.countable
code: instance (priority := 500) SetCoe.countable [Countable α] (s : Set α) : Countable s 
goal: Countable ↑s

full_name: instCountablePSum
code: instance [Countable α] [Countable β] : Countable (α ⊕' β) 
goal: Countable (α ⊕' β)

full_name: instCountablePProd
code: instance [Countable α] [Countable β] : Countable (PProd α β) 
goal: Countable (PProd α β)

full_name: instCountablePSigma
code: instance [Countable α] [∀ a, Countable (π a)] : Countable (PSigma π) 
goal: Countable (PSigma π)

full_name: instCountableForallOfFinite
code: instance [Finite α] [∀ a, Countable (π a)] : Countable (∀ a, π a) 
goal: Countable ((a : α) → π a)
File: Mathlib/Data/Countable/Small.lean

full_name: Countable.toSmall
code: instance (priority := 100) Countable.toSmall (α : Type v) [Countable α] : Small.{w} α 
goal: Small.{w, v} α
File: Mathlib/Data/SProd.lean

full_name: SProd.sprod
code: /-- Notation type class for the set product `×ˢ`. -/
class SProd (α : Type u) (β : Type v) (γ : outParam (Type w)) where
  /-- The cartesian product `s ×ˢ t` is the set of `(a, b)` such that `a ∈ s` and `b ∈ t`. -/
  sprod : α → β → γ
goal: α → β → γ

full_name: SProd
code: /-- Notation type class for the set product `×ˢ`. -/
class SProd (α : Type u) (β : Type v) (γ : outParam (Type w)) where
  /-- The cartesian product `s ×ˢ t` is the set of `(a, b)` such that `a ∈ s` and `b ∈ t`. -/
  sprod : α → β → γ
goal: Type (max (max u v) w)

full_name: «_aux_Mathlib_Data_SProd___macroRules_term_×ˢ__1»
code: @[inherit_doc SProd.sprod] infixr:82 " ×ˢ " => SProd.sprod
goal: Lean.Macro

full_name: _aux_Mathlib_Data_SProd___unexpand_SProd_sprod_1
code: @[inherit_doc SProd.sprod] infixr:82 " ×ˢ " => SProd.sprod
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Data_SProd___macroRules_term_×ˢ__2»
code: macro_rules | `($x ×ˢ $y)   => `(fbinop% SProd.sprod $x $y)
goal: Lean.Macro
File: Mathlib/Data/Set/Pointwise/BoundedMul.lean

full_name: Set.BddAbove.add
code: @[to_additive]
theorem BddAbove.mul [OrderedCommMonoid α] {A B : Set α} (hA : BddAbove A) (hB : BddAbove B) :
    BddAbove (A * B) 
goal: BddAbove (A + B)

full_name: Set.BddAbove.mul
code: @[to_additive]
theorem BddAbove.mul [OrderedCommMonoid α] {A B : Set α} (hA : BddAbove A) (hB : BddAbove B) :
    BddAbove (A * B) 
goal: BddAbove (A * B)
File: Mathlib/Data/Set/Pointwise/Support.lean

full_name: mulSupport_comp_inv_smul
code: theorem mulSupport_comp_inv_smul [One γ] (c : α) (f : β → γ) :
    (mulSupport fun x ↦ f (c⁻¹ • x)) = c • mulSupport f 
goal: (Function.mulSupport fun x => f (c⁻¹ • x)) = c • Function.mulSupport f

full_name: support_comp_inv_smul
code: theorem support_comp_inv_smul [Zero γ] (c : α) (f : β → γ) :
    (support fun x ↦ f (c⁻¹ • x)) = c • support f 
goal: (Function.support fun x => f (c⁻¹ • x)) = c • Function.support f

full_name: mulSupport_comp_inv_smul₀
code: theorem mulSupport_comp_inv_smul₀ [One γ] {c : α} (hc : c ≠ 0) (f : β → γ) :
    (mulSupport fun x ↦ f (c⁻¹ • x)) = c • mulSupport f 
goal: (Function.mulSupport fun x => f (c⁻¹ • x)) = c • Function.mulSupport f

full_name: support_comp_inv_smul₀
code: theorem support_comp_inv_smul₀ [Zero γ] {c : α} (hc : c ≠ 0) (f : β → γ) :
    (support fun x ↦ f (c⁻¹ • x)) = c • support f 
goal: (Function.support fun x => f (c⁻¹ • x)) = c • Function.support f