ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Data/Nat/BitIndices.lean

full_name: Nat.bitIndices
code: /-- The function which maps each natural number `∑ i in s, 2^i` to the list of
elements of `s` in increasing order. -/
def bitIndices (n : ℕ) : List ℕ 
goal: List ℕ

full_name: Nat.bitIndices_zero
code: @[simp] theorem bitIndices_zero : bitIndices 0 = [] 
goal: Nat.bitIndices 0 = []

full_name: Nat.bitIndices_one
code: @[simp] theorem bitIndices_one : bitIndices 1 = [0] 
goal: Nat.bitIndices 1 = [0]

full_name: Nat.bitIndices_bit_true
code: theorem bitIndices_bit_true (n : ℕ) :
    bitIndices (bit true n) = 0 :: ((bitIndices n).map (· + 1)) 
goal: (Nat.bit true n).bitIndices = 0 :: List.map (fun x => x + 1) n.bitIndices

full_name: Nat.bitIndices_bit_false
code: theorem bitIndices_bit_false (n : ℕ) :
    bitIndices (bit false n) = (bitIndices n).map (· + 1) 
goal: (Nat.bit false n).bitIndices = List.map (fun x => x + 1) n.bitIndices

full_name: Nat.bitIndices_two_mul_add_one
code: @[simp] theorem bitIndices_two_mul_add_one (n : ℕ) :
    bitIndices (2 * n + 1) = 0 :: (bitIndices n).map (· + 1) 
goal: (2 * n + 1).bitIndices = 0 :: List.map (fun x => x + 1) n.bitIndices

full_name: Nat.bitIndices_two_mul
code: @[simp] theorem bitIndices_two_mul (n : ℕ) :
    bitIndices (2 * n) = (bitIndices n).map (· + 1) 
goal: (2 * n).bitIndices = List.map (fun x => x + 1) n.bitIndices

full_name: Nat.bitIndices_sorted
code: @[simp] theorem bitIndices_sorted {n : ℕ} : n.bitIndices.Sorted (· < ·) 
goal: List.Sorted (fun x x_1 => x < x_1) n.bitIndices

full_name: Nat.bitIndices_two_pow_mul
code: @[simp] theorem bitIndices_two_pow_mul (k n : ℕ) :
    bitIndices (2^k * n) = (bitIndices n).map (· + k) 
goal: (2 ^ k * n).bitIndices = List.map (fun x => x + k) n.bitIndices

full_name: Nat.bitIndices_two_pow
code: @[simp] theorem bitIndices_two_pow (k : ℕ) : bitIndices (2^k) = [k] 
goal: (2 ^ k).bitIndices = [k]

full_name: Nat.twoPowSum_bitIndices
code: @[simp] theorem twoPowSum_bitIndices (n : ℕ) : (n.bitIndices.map (fun i ↦ 2 ^ i)).sum = n 
goal: (List.map (fun i => 2 ^ i) n.bitIndices).sum = n

full_name: Nat.bitIndices_twoPowsum
code: /-- Together with `Nat.twoPowSum_bitIndices`, this implies a bijection between `ℕ` and `Finset ℕ`.
See `Finset.equivBitIndices` for this bijection. -/
theorem bitIndices_twoPowsum {L : List ℕ} (hL : List.Sorted (· < ·) L) :
    (L.map (fun i ↦ 2^i)).sum.bitIndices = L 
goal: (List.map (fun i => 2 ^ i) L).sum.bitIndices = L

full_name: Nat.two_pow_le_of_mem_bitIndices
code: theorem two_pow_le_of_mem_bitIndices (ha : a ∈ n.bitIndices) : 2^a ≤ n 
goal: 2 ^ a ≤ n

full_name: Nat.not_mem_bitIndices_self
code: theorem not_mem_bitIndices_self (n : ℕ) : n ∉ n.bitIndices 
goal: n ∉ n.bitIndices
File: Mathlib/Data/Array/ExtractLemmas.lean

full_name: Array.extract_eq_nil_of_start_eq_end
code: @[simp]
theorem extract_eq_nil_of_start_eq_end {a : Array α} :
    a.extract i i = #[] 
goal: a.extract i i = #[]

full_name: Array.extract_append_left
code: theorem extract_append_left {a b : Array α} {i j : Nat} (h : j ≤ a.size) :
    (a ++ b).extract i j = a.extract i j 
goal: (a ++ b).extract i j = a.extract i j

full_name: Array.extract_append_right
code: theorem extract_append_right {a b : Array α} {i j : Nat} (h : a.size ≤ i) :
    (a ++ b).extract i j = b.extract (i - a.size) (j - a.size) 
goal: (a ++ b).extract i j = b.extract (i - a.size) (j - a.size)

full_name: Array.extract_eq_of_size_le_end
code: theorem extract_eq_of_size_le_end {l p : Nat} {a : Array α} (h : a.size ≤ l) :
    a.extract p l = a.extract p a.size 
goal: a.extract p l = a.extract p a.size

full_name: Array.extract_extract
code: theorem extract_extract {s1 e2 e1 s2 : Nat} {a : Array α} (h : s1 + e2 ≤ e1) :
    (a.extract s1 e1).extract s2 e2 = a.extract (s1 + s2) (s1 + e2) 
goal: (a.extract s1 e1).extract s2 e2 = a.extract (s1 + s2) (s1 + e2)
File: Mathlib/Data/Real/Star.lean

full_name: instStarRingReal
code: /-- The real numbers are a `*`-ring, with the trivial `*`-structure. -/
instance : StarRing ℝ 
goal: StarRing ℝ

full_name: instTrivialStarReal
code: instance : TrivialStar ℝ 
goal: TrivialStar ℝ
File: Mathlib/Data/Real/StarOrdered.lean

full_name: Real.instStarOrderedRing
code: /-- Although the instance `RCLike.toStarOrderedRing` exists, it is locked behind the
`ComplexOrder` scope because currently the order on `ℂ` is not enabled globally. But we
want `StarOrderedRing ℝ` to be available globally, so we include this instance separately.
In addition, providing this instance here makes it available earlier in the import
hierarchy; otherwise in order to access it we would need to import `Mathlib.Analysis.RCLike.Basic`.
-/
instance Real.instStarOrderedRing : StarOrderedRing ℝ 
goal: StarOrderedRing ℝ

full_name: NNReal.instStarOrderedRing
code: instance NNReal.instStarOrderedRing : StarOrderedRing ℝ≥0 
goal: StarOrderedRing ℝ≥0
File: Mathlib/Data/Real/Sign.lean

full_name: Real.sign
code: /-- The sign function that maps negative real numbers to -1, positive numbers to 1, and 0
otherwise. -/
noncomputable def sign (r : ℝ) : ℝ 
goal: ℝ

full_name: Real.sign_of_neg
code: theorem sign_of_neg {r : ℝ} (hr : r < 0) : sign r = -1 
goal: r.sign = -1

full_name: Real.sign_of_pos
code: theorem sign_of_pos {r : ℝ} (hr : 0 < r) : sign r = 1 
goal: r.sign = 1

full_name: Real.sign_zero
code: @[simp]
theorem sign_zero : sign 0 = 0 
goal: Real.sign 0 = 0

full_name: Real.sign_one
code: @[simp]
theorem sign_one : sign 1 = 1 
goal: Real.sign 1 = 1

full_name: Real.sign_apply_eq
code: theorem sign_apply_eq (r : ℝ) : sign r = -1 ∨ sign r = 0 ∨ sign r = 1 
goal: r.sign = -1 ∨ r.sign = 0 ∨ r.sign = 1

full_name: Real.sign_apply_eq_of_ne_zero
code: /-- This lemma is useful for working with `ℝˣ` -/
theorem sign_apply_eq_of_ne_zero (r : ℝ) (h : r ≠ 0) : sign r = -1 ∨ sign r = 1 
goal: r.sign = -1 ∨ r.sign = 1

full_name: Real.sign_eq_zero_iff
code: @[simp]
theorem sign_eq_zero_iff {r : ℝ} : sign r = 0 ↔ r = 0 
goal: r.sign = 0 ↔ r = 0

full_name: Real.sign_intCast
code: theorem sign_intCast (z : ℤ) : sign (z : ℝ) = ↑(Int.sign z) 
goal: (↑z).sign = ↑z.sign

full_name: Real.sign_neg
code: theorem sign_neg {r : ℝ} : sign (-r) = -sign r 
goal: (-r).sign = -r.sign

full_name: Real.sign_mul_nonneg
code: theorem sign_mul_nonneg (r : ℝ) : 0 ≤ sign r * r 
goal: 0 ≤ r.sign * r

full_name: Real.sign_mul_pos_of_ne_zero
code: theorem sign_mul_pos_of_ne_zero (r : ℝ) (hr : r ≠ 0) : 0 < sign r * r 
goal: 0 < r.sign * r

full_name: Real.inv_sign
code: @[simp]
theorem inv_sign (r : ℝ) : (sign r)⁻¹ = sign r 
goal: r.sign⁻¹ = r.sign

full_name: Real.sign_inv
code: @[simp]
theorem sign_inv (r : ℝ) : sign r⁻¹ = sign r 
goal: r⁻¹.sign = r.sign
File: Mathlib/Data/W/Cardinal.lean

full_name: WType.cardinal_mk_eq_sum'
code: theorem cardinal_mk_eq_sum' : #(WType β) = sum (fun a : α => #(WType β) ^ lift.{u} #(β a)) 
goal: Cardinal.mk (WType β) = Cardinal.sum fun a => Cardinal.mk (WType β) ^ Cardinal.lift.{u, v} (Cardinal.mk (β a))

full_name: WType.cardinal_mk_le_of_le'
code: /-- `#(WType β)` is the least cardinal `κ` such that `sum (fun a : α ↦ κ ^ #(β a)) ≤ κ` -/
theorem cardinal_mk_le_of_le' {κ : Cardinal.{max u v}}
    (hκ : (sum fun a : α => κ ^ lift.{u} #(β a)) ≤ κ) :
    #(WType β) ≤ κ 
goal: Cardinal.mk (WType β) ≤ κ

full_name: WType.cardinal_mk_le_max_aleph0_of_finite'
code: /-- If, for any `a : α`, `β a` is finite, then the cardinality of `WType β`
  is at most the maximum of the cardinality of `α` and `ℵ₀`  -/
theorem cardinal_mk_le_max_aleph0_of_finite' [∀ a, Finite (β a)] :
    #(WType β) ≤ max (lift.{v} #α) ℵ₀ 
goal: Cardinal.mk (WType β) ≤ max (Cardinal.lift.{v, u} (Cardinal.mk α)) Cardinal.aleph0

full_name: WType.cardinal_mk_eq_sum
code: theorem cardinal_mk_eq_sum : #(WType β) = sum (fun a : α => #(WType β) ^ #(β a)) 
goal: Cardinal.mk (WType β) = Cardinal.sum fun a => Cardinal.mk (WType β) ^ Cardinal.mk (β a)

full_name: WType.cardinal_mk_le_of_le
code: /-- `#(WType β)` is the least cardinal `κ` such that `sum (fun a : α ↦ κ ^ #(β a)) ≤ κ` -/
theorem cardinal_mk_le_of_le {κ : Cardinal.{u}} (hκ : (sum fun a : α => κ ^ #(β a)) ≤ κ) :
    #(WType β) ≤ κ 
goal: Cardinal.mk (WType β) ≤ κ

full_name: WType.cardinal_mk_le_max_aleph0_of_finite
code: /-- If, for any `a : α`, `β a` is finite, then the cardinality of `WType β`
  is at most the maximum of the cardinality of `α` and `ℵ₀`  -/
theorem cardinal_mk_le_max_aleph0_of_finite [∀ a, Finite (β a)] : #(WType β) ≤ max #α ℵ₀ 
goal: Cardinal.mk (WType β) ≤ max (Cardinal.mk α) Cardinal.aleph0
File: Mathlib/Data/String/Defs.lean

full_name: String.leftpad
code: /-- Pad `s : String` with repeated occurrences of `c : Char` until it's of length `n`.
  If `s` is initially larger than `n`, just return `s`. -/
def leftpad (n : Nat) (c : Char := ' ') (s : String) : String 
goal: String

full_name: String.replicate
code: /-- Construct the string consisting of `n` copies of the character `c`. -/
def replicate (n : Nat) (c : Char) : String 
goal: String

full_name: String.rightpad
code: /-- Pad `s : String` with repeated occurrences of `c : Char` on the right until it's of length `n`.
  If `s` is initially larger than `n`, just return `s`. -/
def rightpad (n : Nat) (c : Char := ' ') (s : String) : String 
goal: String

full_name: String.IsPrefix
code: /-- `s.IsPrefix t` checks if the string `s` is a prefix of the string `t`. -/
def IsPrefix : String → String → Prop
  
goal: String → String → Prop

full_name: String.IsSuffix
code: /-- `s.IsSuffix t` checks if the string `s` is a suffix of the string `t`. -/
def IsSuffix : String → String → Prop
  
goal: String → String → Prop

full_name: String.mapTokens
code: /-- `String.mapTokens c f s` tokenizes `s : string` on `c : char`, maps `f` over each token, and
then reassembles the string by intercalating the separator token `c` over the mapped tokens. -/
def mapTokens (c : Char) (f : String → String) : String → String 
goal: String → String

full_name: String.head
code: /-- Produce the head character from the string `s`, if `s` is not empty, otherwise `'A'`. -/
def head (s : String) : Char 
goal: Char
File: Mathlib/Data/String/Lemmas.lean

full_name: String.congr_append
code: lemma congr_append : ∀ (a b : String), a ++ b = String.mk (a.data ++ b.data)
  
goal: a ++ b = { data := a.data ++ b.data }

full_name: String.length_replicate
code: @[simp] lemma length_replicate (n : ℕ) (c : Char) : (replicate n c).length = n 
goal: (String.replicate n c).length = n

full_name: String.length_eq_list_length
code: lemma length_eq_list_length (l : List Char) : (String.mk l).length = l.length 
goal: { data := l }.length = l.length

full_name: String.leftpad_length
code: /-- The length of the String returned by `String.leftpad n a c` is equal
  to the larger of `n` and `s.length` -/
@[simp] lemma leftpad_length (n : ℕ) (c : Char) :
    ∀ (s : String), (leftpad n c s).length = max n s.length
  
goal: (String.leftpad n c s).length = max n s.length

full_name: String.leftpad_prefix
code: lemma leftpad_prefix (n : ℕ) (c : Char) : ∀ s, IsPrefix (replicate (n - length s) c) (leftpad n c s)
  
goal: (String.replicate (n - s.length) c).IsPrefix (String.leftpad n c s)

full_name: String.leftpad_suffix
code: lemma leftpad_suffix (n : ℕ) (c : Char) : ∀ s, IsSuffix s (leftpad n c s)
  
goal: s.IsSuffix (String.leftpad n c s)
File: Mathlib/Data/Real/Pointwise.lean

full_name: Real.sInf_smul_of_nonneg
code: theorem Real.sInf_smul_of_nonneg (ha : 0 ≤ a) (s : Set ℝ) : sInf (a • s) = a • sInf s 
goal: sInf (a • s) = a • sInf s

full_name: Real.smul_iInf_of_nonneg
code: theorem Real.smul_iInf_of_nonneg (ha : 0 ≤ a) (f : ι → ℝ) : (a • ⨅ i, f i) = ⨅ i, a • f i 
goal: a • ⨅ i, f i = ⨅ i, a • f i

full_name: Real.sSup_smul_of_nonneg
code: theorem Real.sSup_smul_of_nonneg (ha : 0 ≤ a) (s : Set ℝ) : sSup (a • s) = a • sSup s 
goal: sSup (a • s) = a • sSup s

full_name: Real.smul_iSup_of_nonneg
code: theorem Real.smul_iSup_of_nonneg (ha : 0 ≤ a) (f : ι → ℝ) : (a • ⨆ i, f i) = ⨆ i, a • f i 
goal: a • ⨆ i, f i = ⨆ i, a • f i

full_name: Real.sInf_smul_of_nonpos
code: theorem Real.sInf_smul_of_nonpos (ha : a ≤ 0) (s : Set ℝ) : sInf (a • s) = a • sSup s 
goal: sInf (a • s) = a • sSup s

full_name: Real.smul_iSup_of_nonpos
code: theorem Real.smul_iSup_of_nonpos (ha : a ≤ 0) (f : ι → ℝ) : (a • ⨆ i, f i) = ⨅ i, a • f i 
goal: a • ⨆ i, f i = ⨅ i, a • f i

full_name: Real.sSup_smul_of_nonpos
code: theorem Real.sSup_smul_of_nonpos (ha : a ≤ 0) (s : Set ℝ) : sSup (a • s) = a • sInf s 
goal: sSup (a • s) = a • sInf s

full_name: Real.smul_iInf_of_nonpos
code: theorem Real.smul_iInf_of_nonpos (ha : a ≤ 0) (f : ι → ℝ) : (a • ⨅ i, f i) = ⨆ i, a • f i 
goal: a • ⨅ i, f i = ⨆ i, a • f i

full_name: Real.mul_iInf_of_nonneg
code: theorem Real.mul_iInf_of_nonneg (ha : 0 ≤ r) (f : ι → ℝ) : (r * ⨅ i, f i) = ⨅ i, r * f i 
goal: r * ⨅ i, f i = ⨅ i, r * f i

full_name: Real.mul_iSup_of_nonneg
code: theorem Real.mul_iSup_of_nonneg (ha : 0 ≤ r) (f : ι → ℝ) : (r * ⨆ i, f i) = ⨆ i, r * f i 
goal: r * ⨆ i, f i = ⨆ i, r * f i

full_name: Real.mul_iInf_of_nonpos
code: theorem Real.mul_iInf_of_nonpos (ha : r ≤ 0) (f : ι → ℝ) : (r * ⨅ i, f i) = ⨆ i, r * f i 
goal: r * ⨅ i, f i = ⨆ i, r * f i

full_name: Real.mul_iSup_of_nonpos
code: theorem Real.mul_iSup_of_nonpos (ha : r ≤ 0) (f : ι → ℝ) : (r * ⨆ i, f i) = ⨅ i, r * f i 
goal: r * ⨆ i, f i = ⨅ i, r * f i

full_name: Real.iInf_mul_of_nonneg
code: theorem Real.iInf_mul_of_nonneg (ha : 0 ≤ r) (f : ι → ℝ) : (⨅ i, f i) * r = ⨅ i, f i * r 
goal: (⨅ i, f i) * r = ⨅ i, f i * r

full_name: Real.iSup_mul_of_nonneg
code: theorem Real.iSup_mul_of_nonneg (ha : 0 ≤ r) (f : ι → ℝ) : (⨆ i, f i) * r = ⨆ i, f i * r 
goal: (⨆ i, f i) * r = ⨆ i, f i * r

full_name: Real.iInf_mul_of_nonpos
code: theorem Real.iInf_mul_of_nonpos (ha : r ≤ 0) (f : ι → ℝ) : (⨅ i, f i) * r = ⨆ i, f i * r 
goal: (⨅ i, f i) * r = ⨆ i, f i * r

full_name: Real.iSup_mul_of_nonpos
code: theorem Real.iSup_mul_of_nonpos (ha : r ≤ 0) (f : ι → ℝ) : (⨆ i, f i) * r = ⨅ i, f i * r 
goal: (⨆ i, f i) * r = ⨅ i, f i * r
File: Mathlib/Data/Real/Pi/Wallis.lean

full_name: Real.Wallis.W
code: /-- The product of the first `k` terms in Wallis' formula for `π`. -/
noncomputable def W (k : ℕ) : ℝ 
goal: ℝ

full_name: Real.Wallis.W_succ
code: theorem W_succ (k : ℕ) :
    W (k + 1) = W k * ((2 * k + 2) / (2 * k + 1) * ((2 * k + 2) / (2 * k + 3))) 
goal: Real.Wallis.W (k + 1) = Real.Wallis.W k * ((2 * ↑k + 2) / (2 * ↑k + 1) * ((2 * ↑k + 2) / (2 * ↑k + 3)))

full_name: Real.Wallis.W_pos
code: theorem W_pos (k : ℕ) : 0 < W k 
goal: 0 < Real.Wallis.W k

full_name: Real.Wallis.W_eq_factorial_ratio
code: theorem W_eq_factorial_ratio (n : ℕ) :
    W n = 2 ^ (4 * n) * n ! ^ 4 / ((2 * n)! ^ 2 * (2 * n + 1)) 
goal: Real.Wallis.W n = 2 ^ (4 * n) * ↑n ! ^ 4 / (↑(2 * n)! ^ 2 * (2 * ↑n + 1))

full_name: Real.Wallis.W_eq_integral_sin_pow_div_integral_sin_pow
code: theorem W_eq_integral_sin_pow_div_integral_sin_pow (k : ℕ) : (π / 2)⁻¹ * W k =
    (∫ x : ℝ in (0)..π, sin x ^ (2 * k + 1)) / ∫ x : ℝ in (0)..π, sin x ^ (2 * k) 
goal: (π / 2)⁻¹ * Real.Wallis.W k = (∫ (x : ℝ) in 0 ..π, Real.sin x ^ (2 * k + 1)) / ∫ (x : ℝ) in 0 ..π, Real.sin x ^ (2 * k)

full_name: Real.Wallis.W_le
code: theorem W_le (k : ℕ) : W k ≤ π / 2 
goal: Real.Wallis.W k ≤ π / 2

full_name: Real.Wallis.le_W
code: theorem le_W (k : ℕ) : ((2 : ℝ) * k + 1) / (2 * k + 2) * (π / 2) ≤ W k 
goal: (2 * ↑k + 1) / (2 * ↑k + 2) * (π / 2) ≤ Real.Wallis.W k

full_name: Real.Wallis.tendsto_W_nhds_pi_div_two
code: theorem tendsto_W_nhds_pi_div_two : Tendsto W atTop (𝓝 <| π / 2) 
goal: Filter.Tendsto Real.Wallis.W Filter.atTop (𝓝 (π / 2))

full_name: Real.tendsto_prod_pi_div_two
code: /-- Wallis' product formula for `π / 2`. -/
theorem Real.tendsto_prod_pi_div_two :
    Tendsto (fun k => ∏ i ∈ range k, ((2 : ℝ) * i + 2) / (2 * i + 1) * ((2 * i + 2) / (2 * i + 3)))
      atTop (𝓝 (π / 2)) 
goal: Filter.Tendsto (fun k => ∏ i ∈ Finset.range k, (2 * ↑i + 2) / (2 * ↑i + 1) * ((2 * ↑i + 2) / (2 * ↑i + 3))) Filter.atTop
  (𝓝 (π / 2))
File: Mathlib/Data/DFinsupp/Notation.lean

full_name: DFinsupp.elabSingle₀
code: /-- `DFinsupp` elaborator for `single₀`. -/
@[term_elab Finsupp.stxSingle₀]
def elabSingle₀ : Elab.Term.TermElab
  
goal: Lean.Elab.Term.TermElab

full_name: DFinsupp.elabUpdate₀
code: /-- `DFinsupp` elaborator for `update₀`. -/
@[term_elab Finsupp.stxUpdate₀]
def elabUpdate₀ : Elab.Term.TermElab
  
goal: Lean.Elab.Term.TermElab

full_name: DFinsupp.singleUnexpander
code: /-- Unexpander for the `fun₀ | i => x` notation. -/
@[app_unexpander Finsupp.single]
def singleUnexpander : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: DFinsupp.updateUnexpander
code: /-- Unexpander for the `fun₀ | i => x` notation. -/
@[app_unexpander Finsupp.update]
def updateUnexpander : Lean.PrettyPrinter.Unexpander
  
goal: Lean.PrettyPrinter.Unexpander

full_name: DFinsupp.instRepr
code: /-- Display `DFinsupp` using `fun₀` notation. -/
unsafe instance {α : Type*} {β : α → Type*} [Repr α] [∀ i, Repr (β i)] [∀ i, Zero (β i)] :
    Repr (Π₀ a, β a) 
goal: Repr (Π₀ (a : α), β a)
File: Mathlib/Data/Real/Pi/Leibniz.lean

full_name: Real.tendsto_sum_pi_div_four
code: /-- **Leibniz's series for `π`**. The alternating sum of odd number reciprocals is `π / 4`,
proved by using Abel's limit theorem to extend the Maclaurin series of `arctan` to 1. -/
theorem tendsto_sum_pi_div_four :
    Tendsto (fun k => ∑ i ∈ range k, (-1 : ℝ) ^ i / (2 * i + 1)) atTop (𝓝 (π / 4)) 
goal: Filter.Tendsto (fun k => ∑ i ∈ Finset.range k, (-1) ^ i / (2 * ↑i + 1)) Filter.atTop (nhds (Real.pi / 4))
File: Mathlib/Data/DFinsupp/Encodable.lean

full_name: instEncodableDFinsuppOfDecidableNeOfNat
code: instance [Encodable ι] [∀ i, Encodable (α i)] [∀ i (x : α i), Decidable (x ≠ 0)] :
    Encodable (Π₀ i, α i) 
goal: Encodable (Π₀ (i : ι), α i)

full_name: instCountableDFinsupp
code: instance [Countable ι] [∀ i, Countable (α i)] : Countable (Π₀ i, α i) 
goal: Countable (Π₀ (i : ι), α i)
File: Mathlib/Data/Char.lean

full_name: instLinearOrderChar
code: /--
Provides a `LinearOrder` instance on `Char`. `Char` is the type of Unicode scalar values.
-/
instance : LinearOrder Char 
goal: LinearOrder Char
File: Mathlib/Data/Finsupp/Fintype.lean

full_name: Finsupp.fintype
code: noncomputable instance Finsupp.fintype {ι π : Sort _} [DecidableEq ι] [Zero π] [Fintype ι]
    [Fintype π] : Fintype (ι →₀ π) 
goal: Fintype (ι →₀ π)

full_name: Finsupp.infinite_of_left
code: instance Finsupp.infinite_of_left {ι π : Sort _} [Nontrivial π] [Zero π] [Infinite ι] :
    Infinite (ι →₀ π) 
goal: Infinite (ι →₀ π)

full_name: Finsupp.infinite_of_right
code: instance Finsupp.infinite_of_right {ι π : Sort _} [Infinite π] [Zero π] [Nonempty ι] :
    Infinite (ι →₀ π) 
goal: Infinite (ι →₀ π)
File: Mathlib/Data/Finsupp/Antidiagonal.lean

full_name: Finsupp.antidiagonal'
code: /-- The `Finsupp` counterpart of `Multiset.antidiagonal`: the antidiagonal of
`s : α →₀ ℕ` consists of all pairs `(t₁, t₂) : (α →₀ ℕ) × (α →₀ ℕ)` such that `t₁ + t₂ = s`.
The finitely supported function `antidiagonal s` is equal to the multiplicities of these pairs. -/
def antidiagonal' (f : α →₀ ℕ) : (α →₀ ℕ) × (α →₀ ℕ) →₀ ℕ 
goal: (α →₀ ℕ) × (α →₀ ℕ) →₀ ℕ

full_name: Finsupp.instHasAntidiagonal
code: /-- The antidiagonal of `s : α →₀ ℕ` is the finset of all pairs `(t₁, t₂) : (α →₀ ℕ) × (α →₀ ℕ)`
such that `t₁ + t₂ = s`. -/
instance instHasAntidiagonal : HasAntidiagonal (α →₀ ℕ) 
goal: Finset.HasAntidiagonal (α →₀ ℕ)

full_name: Finsupp.antidiagonal_zero
code: @[simp]
theorem antidiagonal_zero : antidiagonal (0 : α →₀ ℕ) = singleton (0, 0) 
goal: Finset.antidiagonal 0 = {(0, 0)}

full_name: Finsupp.prod_antidiagonal_swap
code: @[to_additive]
theorem prod_antidiagonal_swap {M : Type*} [CommMonoid M] (n : α →₀ ℕ)
    (f : (α →₀ ℕ) → (α →₀ ℕ) → M) :
    ∏ p ∈ antidiagonal n, f p.1 p.2 = ∏ p ∈ antidiagonal n, f p.2 p.1 
goal: ∏ p ∈ Finset.antidiagonal n, f p.1 p.2 = ∏ p ∈ Finset.antidiagonal n, f p.2 p.1

full_name: Finsupp.sum_antidiagonal_swap
code: @[to_additive]
theorem prod_antidiagonal_swap {M : Type*} [CommMonoid M] (n : α →₀ ℕ)
    (f : (α →₀ ℕ) → (α →₀ ℕ) → M) :
    ∏ p ∈ antidiagonal n, f p.1 p.2 = ∏ p ∈ antidiagonal n, f p.2 p.1 
goal: ∑ p ∈ Finset.antidiagonal n, f p.1 p.2 = ∑ p ∈ Finset.antidiagonal n, f p.2 p.1

full_name: Finsupp.antidiagonal_single
code: @[simp]
theorem antidiagonal_single (a : α) (n : ℕ) :
    antidiagonal (single a n) = (antidiagonal n).map
      (Function.Embedding.prodMap ⟨_, single_injective a⟩ ⟨_, single_injective a⟩) 
goal: Finset.antidiagonal (Finsupp.single a n) =
  Finset.map ({ toFun := Finsupp.single a, inj' := ⋯ }.prodMap { toFun := Finsupp.single a, inj' := ⋯ })
    (Finset.antidiagonal n)
File: Mathlib/Data/Finsupp/PWO.lean

full_name: Finsupp.isPWO
code: /-- A version of **Dickson's lemma** any subset of functions `σ →₀ α` is partially well
ordered, when `σ` is `Finite` and `α` is a linear well order.
This version uses finsupps on a finite type as it is intended for use with `MVPowerSeries`.
-/
theorem Finsupp.isPWO {α σ : Type*} [Zero α] [LinearOrder α] [IsWellOrder α (· < ·)] [Finite σ]
    (S : Set (σ →₀ α)) : S.IsPWO 
goal: S.IsPWO
File: Mathlib/Data/Finsupp/Fin.lean

full_name: Finsupp.tail
code: /-- `tail` for maps `Fin (n + 1) →₀ M`. See `Fin.tail` for more details. -/
def tail (s : Fin (n + 1) →₀ M) : Fin n →₀ M 
goal: Fin n →₀ M

full_name: Finsupp.cons
code: /-- `cons` for maps `Fin n →₀ M`. See `Fin.cons` for more details. -/
def cons (y : M) (s : Fin n →₀ M) : Fin (n + 1) →₀ M 
goal: Fin (n + 1) →₀ M

full_name: Finsupp.tail_apply
code: theorem tail_apply : tail t i = t i.succ 
goal: t.tail i = t i.succ

full_name: Finsupp.cons_zero
code: @[simp]
theorem cons_zero : cons y s 0 = y 
goal: (Finsupp.cons y s) 0 = y

full_name: Finsupp.cons_succ
code: @[simp]
theorem cons_succ : cons y s i.succ = s i 
goal: (Finsupp.cons y s) i.succ = s i

full_name: Finsupp.tail_cons
code: @[simp]
theorem tail_cons : tail (cons y s) = s 
goal: (Finsupp.cons y s).tail = s

full_name: Finsupp.cons_tail
code: @[simp]
theorem cons_tail : cons (t 0) (tail t) = t 
goal: Finsupp.cons (t 0) t.tail = t

full_name: Finsupp.cons_zero_zero
code: @[simp]
theorem cons_zero_zero : cons 0 (0 : Fin n →₀ M) = 0 
goal: Finsupp.cons 0 0 = 0

full_name: Finsupp.cons_ne_zero_of_left
code: theorem cons_ne_zero_of_left (h : y ≠ 0) : cons y s ≠ 0 
goal: Finsupp.cons y s ≠ 0

full_name: Finsupp.cons_ne_zero_of_right
code: theorem cons_ne_zero_of_right (h : s ≠ 0) : cons y s ≠ 0 
goal: Finsupp.cons y s ≠ 0

full_name: Finsupp.cons_ne_zero_iff
code: theorem cons_ne_zero_iff : cons y s ≠ 0 ↔ y ≠ 0 ∨ s ≠ 0 
goal: Finsupp.cons y s ≠ 0 ↔ y ≠ 0 ∨ s ≠ 0

full_name: Finsupp.cons_support
code: lemma cons_support : (s.cons y).support ⊆ insert 0 (s.support.map (Fin.succEmb n)) 
goal: (Finsupp.cons y s).support ⊆ insert 0 (Finset.map (Fin.succEmb n) s.support)