ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Data/Int/Order/Units.lean

full_name: Int.isUnit_iff_abs_eq
code: theorem isUnit_iff_abs_eq {x : ℤ} : IsUnit x ↔ abs x = 1 
goal: IsUnit x ↔ |x| = 1

full_name: Int.isUnit_sq
code: theorem isUnit_sq {a : ℤ} (ha : IsUnit a) : a ^ 2 = 1 
goal: a ^ 2 = 1

full_name: Int.units_sq
code: @[simp]
theorem units_sq (u : ℤˣ) : u ^ 2 = 1 
goal: u ^ 2 = 1

full_name: Int.units_mul_self
code: @[simp]
theorem units_mul_self (u : ℤˣ) : u * u = 1 
goal: u * u = 1

full_name: Int.units_inv_eq_self
code: @[simp]
theorem units_inv_eq_self (u : ℤˣ) : u⁻¹ = u 
goal: u⁻¹ = u

full_name: Int.units_div_eq_mul
code: theorem units_div_eq_mul (u₁ u₂ : ℤˣ) : u₁ / u₂ = u₁ * u₂ 
goal: u₁ / u₂ = u₁ * u₂

full_name: Int.units_coe_mul_self
code: @[simp]
theorem units_coe_mul_self (u : ℤˣ) : (u * u : ℤ) = 1 
goal: ↑u * ↑u = 1

full_name: Int.neg_one_pow_ne_zero
code: theorem neg_one_pow_ne_zero {n : ℕ} : (-1 : ℤ) ^ n ≠ 0 
goal: (-1) ^ n ≠ 0

full_name: Int.sq_eq_one_of_sq_lt_four
code: theorem sq_eq_one_of_sq_lt_four {x : ℤ} (h1 : x ^ 2 < 4) (h2 : x ≠ 0) : x ^ 2 = 1 
goal: x ^ 2 = 1

full_name: Int.sq_eq_one_of_sq_le_three
code: theorem sq_eq_one_of_sq_le_three {x : ℤ} (h1 : x ^ 2 ≤ 3) (h2 : x ≠ 0) : x ^ 2 = 1 
goal: x ^ 2 = 1

full_name: Int.units_pow_eq_pow_mod_two
code: theorem units_pow_eq_pow_mod_two (u : ℤˣ) (n : ℕ) : u ^ n = u ^ (n % 2) 
goal: u ^ n = u ^ (n % 2)
File: Mathlib/Data/Int/Order/Lemmas.lean

full_name: Int.natAbs_eq_iff_mul_self_eq
code: theorem natAbs_eq_iff_mul_self_eq {a b : ℤ} : a.natAbs = b.natAbs ↔ a * a = b * b 
goal: a.natAbs = b.natAbs ↔ a * a = b * b

full_name: Int.natAbs_lt_iff_mul_self_lt
code: theorem natAbs_lt_iff_mul_self_lt {a b : ℤ} : a.natAbs < b.natAbs ↔ a * a < b * b 
goal: a.natAbs < b.natAbs ↔ a * a < b * b

full_name: Int.natAbs_le_iff_mul_self_le
code: theorem natAbs_le_iff_mul_self_le {a b : ℤ} : a.natAbs ≤ b.natAbs ↔ a * a ≤ b * b 
goal: a.natAbs ≤ b.natAbs ↔ a * a ≤ b * b

full_name: Int.eq_zero_of_abs_lt_dvd
code: theorem eq_zero_of_abs_lt_dvd {m x : ℤ} (h1 : m ∣ x) (h2 : |x| < m) : x = 0 
goal: x = 0
File: Mathlib/Data/Int/Notation.lean

full_name: _aux_Mathlib_Data_Int_Notation___macroRules_termℤ_1
code: @[inherit_doc] notation "ℤ" => Int
goal: Lean.Macro

full_name: _aux_Mathlib_Data_Int_Notation___unexpand_Int_1
code: @[inherit_doc] notation "ℤ" => Int
goal: Lean.PrettyPrinter.Unexpander
File: Mathlib/Data/Int/NatPrime.lean

full_name: Int.not_prime_of_int_mul
code: theorem not_prime_of_int_mul {a b : ℤ} {c : ℕ} (ha : a.natAbs ≠ 1) (hb : b.natAbs ≠ 1)
    (hc : a * b = (c : ℤ)) : ¬Nat.Prime c 
goal: ¬Nat.Prime c

full_name: Int.succ_dvd_or_succ_dvd_of_succ_sum_dvd_mul
code: theorem succ_dvd_or_succ_dvd_of_succ_sum_dvd_mul {p : ℕ} (p_prime : Nat.Prime p) {m n : ℤ}
    {k l : ℕ} (hpm : ↑(p ^ k) ∣ m) (hpn : ↑(p ^ l) ∣ n) (hpmn : ↑(p ^ (k + l + 1)) ∣ m * n) :
    ↑(p ^ (k + 1)) ∣ m ∨ ↑(p ^ (l + 1)) ∣ n 
goal: ↑(p ^ (k + 1)) ∣ m ∨ ↑(p ^ (l + 1)) ∣ n

full_name: Int.Prime.dvd_natAbs_of_coe_dvd_sq
code: theorem Prime.dvd_natAbs_of_coe_dvd_sq {p : ℕ} (hp : p.Prime) (k : ℤ) (h : (p : ℤ) ∣ k ^ 2) :
    p ∣ k.natAbs 
goal: p ∣ k.natAbs
File: Mathlib/Data/Int/ConditionallyCompleteOrder.lean

full_name: instConditionallyCompleteLinearOrder
code: instance instConditionallyCompleteLinearOrder : ConditionallyCompleteLinearOrder ℤ 
goal: ConditionallyCompleteLinearOrder ℤ

full_name: Int.csSup_eq_greatest_of_bdd
code: theorem csSup_eq_greatest_of_bdd {s : Set ℤ} [DecidablePred (· ∈ s)] (b : ℤ) (Hb : ∀ z ∈ s, z ≤ b)
    (Hinh : ∃ z : ℤ, z ∈ s) : sSup s = greatestOfBdd b Hb Hinh 
goal: sSup s = ↑(b.greatestOfBdd Hb Hinh)

full_name: Int.csSup_empty
code: @[simp]
theorem csSup_empty : sSup (∅ : Set ℤ) = 0 
goal: sSup ∅ = 0

full_name: Int.csSup_of_not_bdd_above
code: theorem csSup_of_not_bdd_above {s : Set ℤ} (h : ¬BddAbove s) : sSup s = 0 
goal: sSup s = 0

full_name: Int.csInf_eq_least_of_bdd
code: theorem csInf_eq_least_of_bdd {s : Set ℤ} [DecidablePred (· ∈ s)] (b : ℤ) (Hb : ∀ z ∈ s, b ≤ z)
    (Hinh : ∃ z : ℤ, z ∈ s) : sInf s = leastOfBdd b Hb Hinh 
goal: sInf s = ↑(b.leastOfBdd Hb Hinh)

full_name: Int.csInf_empty
code: @[simp]
theorem csInf_empty : sInf (∅ : Set ℤ) = 0 
goal: sInf ∅ = 0

full_name: Int.csInf_of_not_bdd_below
code: theorem csInf_of_not_bdd_below {s : Set ℤ} (h : ¬BddBelow s) : sInf s = 0 
goal: sInf s = 0

full_name: Int.csSup_mem
code: theorem csSup_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddAbove s) : sSup s ∈ s 
goal: sSup s ∈ s

full_name: Int.csInf_mem
code: theorem csInf_mem {s : Set ℤ} (h1 : s.Nonempty) (h2 : BddBelow s) : sInf s ∈ s 
goal: sInf s ∈ s
File: Mathlib/Data/Int/SuccPred.lean

full_name: Int.instSuccOrder
code: @[instance] abbrev instSuccOrder : SuccOrder ℤ 
goal: SuccOrder ℤ

full_name: Int.instPredOrder
code: @[instance] abbrev instPredOrder : PredOrder ℤ 
goal: PredOrder ℤ

full_name: Int.succ_eq_succ
code: @[simp]
theorem succ_eq_succ : Order.succ = succ 
goal: Order.succ = Int.succ

full_name: Int.pred_eq_pred
code: @[simp]
theorem pred_eq_pred : Order.pred = pred 
goal: Order.pred = Int.pred

full_name: Int.pos_iff_one_le
code: theorem pos_iff_one_le {a : ℤ} : 0 < a ↔ 1 ≤ a 
goal: 0 < a ↔ 1 ≤ a

full_name: Int.succ_iterate
code: theorem succ_iterate (a : ℤ) : ∀ n, succ^[n] a = a + n
  
goal: Int.succ^[n] a = a + ↑n

full_name: Int.pred_iterate
code: theorem pred_iterate (a : ℤ) : ∀ n, pred^[n] a = a - n
  
goal: Int.pred^[n] a = a - ↑n

full_name: Int.instIsSuccArchimedean
code: instance : IsSuccArchimedean ℤ 
goal: IsSuccArchimedean ℤ

full_name: Int.instIsPredArchimedean
code: instance : IsPredArchimedean ℤ 
goal: IsPredArchimedean ℤ

full_name: Int.covBy_iff_succ_eq
code: protected theorem covBy_iff_succ_eq {m n : ℤ} : m ⋖ n ↔ m + 1 = n 
goal: m ⋖ n ↔ m + 1 = n

full_name: Int.sub_one_covBy
code: @[simp]
theorem sub_one_covBy (z : ℤ) : z - 1 ⋖ z 
goal: z - 1 ⋖ z

full_name: Int.covBy_add_one
code: @[simp]
theorem covBy_add_one (z : ℤ) : z ⋖ z + 1 
goal: z ⋖ z + 1

full_name: Int.natCast_covBy
code: @[simp, norm_cast]
theorem natCast_covBy {a b : ℕ} : (a : ℤ) ⋖ b ↔ a ⋖ b 
goal: ↑a ⋖ ↑b ↔ a ⋖ b
File: Mathlib/Data/Int/Associated.lean

full_name: Int.natAbs_eq_iff_associated
code: theorem Int.natAbs_eq_iff_associated {a b : ℤ} : a.natAbs = b.natAbs ↔ Associated a b 
goal: a.natAbs = b.natAbs ↔ Associated a b
File: Mathlib/Data/Int/LeastGreatest.lean

full_name: Int.leastOfBdd
code: /-- A computable version of `exists_least_of_bdd`: given a decidable predicate on the
integers, with an explicit lower bound and a proof that it is somewhere true, return
the least value for which the predicate is true. -/
def leastOfBdd {P : ℤ → Prop} [DecidablePred P] (b : ℤ) (Hb : ∀ z : ℤ, P z → b ≤ z)
    (Hinh : ∃ z : ℤ, P z) : { lb : ℤ // P lb ∧ ∀ z : ℤ, P z → lb ≤ z } 
goal: { lb // P lb ∧ ∀ (z : ℤ), P z → lb ≤ z }

full_name: Int.exists_least_of_bdd
code: /--
    If `P : ℤ → Prop` is a predicate such that the set `{m : P m}` is bounded below and nonempty,
    then this set has the least element. This lemma uses classical logic to avoid assumption
    `[DecidablePred P]`. See `Int.leastOfBdd` for a constructive counterpart. -/
theorem exists_least_of_bdd
    {P : ℤ → Prop}
    (Hbdd : ∃ b : ℤ , ∀ z : ℤ , P z → b ≤ z)
    (Hinh : ∃ z : ℤ , P z) : ∃ lb : ℤ , P lb ∧ ∀ z : ℤ , P z → lb ≤ z 
goal: ∃ lb, P lb ∧ ∀ (z : ℤ), P z → lb ≤ z

full_name: Int.coe_leastOfBdd_eq
code: theorem coe_leastOfBdd_eq {P : ℤ → Prop} [DecidablePred P] {b b' : ℤ} (Hb : ∀ z : ℤ, P z → b ≤ z)
    (Hb' : ∀ z : ℤ, P z → b' ≤ z) (Hinh : ∃ z : ℤ, P z) :
    (leastOfBdd b Hb Hinh : ℤ) = leastOfBdd b' Hb' Hinh 
goal: ↑(b.leastOfBdd Hb Hinh) = ↑(b'.leastOfBdd Hb' Hinh)

full_name: Int.greatestOfBdd
code: /-- A computable version of `exists_greatest_of_bdd`: given a decidable predicate on the
integers, with an explicit upper bound and a proof that it is somewhere true, return
the greatest value for which the predicate is true. -/
def greatestOfBdd {P : ℤ → Prop} [DecidablePred P] (b : ℤ) (Hb : ∀ z : ℤ, P z → z ≤ b)
    (Hinh : ∃ z : ℤ, P z) : { ub : ℤ // P ub ∧ ∀ z : ℤ, P z → z ≤ ub } 
goal: { ub // P ub ∧ ∀ (z : ℤ), P z → z ≤ ub }

full_name: Int.exists_greatest_of_bdd
code: /--
    If `P : ℤ → Prop` is a predicate such that the set `{m : P m}` is bounded above and nonempty,
    then this set has the greatest element. This lemma uses classical logic to avoid assumption
    `[DecidablePred P]`. See `Int.greatestOfBdd` for a constructive counterpart. -/
theorem exists_greatest_of_bdd
    {P : ℤ → Prop}
    (Hbdd : ∃ b : ℤ , ∀ z : ℤ , P z → z ≤ b)
    (Hinh : ∃ z : ℤ , P z) : ∃ ub : ℤ , P ub ∧ ∀ z : ℤ , P z → z ≤ ub 
goal: ∃ ub, P ub ∧ ∀ (z : ℤ), P z → z ≤ ub

full_name: Int.coe_greatestOfBdd_eq
code: theorem coe_greatestOfBdd_eq {P : ℤ → Prop} [DecidablePred P] {b b' : ℤ}
    (Hb : ∀ z : ℤ, P z → z ≤ b) (Hb' : ∀ z : ℤ, P z → z ≤ b') (Hinh : ∃ z : ℤ, P z) :
    (greatestOfBdd b Hb Hinh : ℤ) = greatestOfBdd b' Hb' Hinh 
goal: ↑(b.greatestOfBdd Hb Hinh) = ↑(b'.greatestOfBdd Hb' Hinh)
File: Mathlib/Data/Int/Star.lean

full_name: Int.addSubmonoid_closure_range_pow
code: @[simp] lemma addSubmonoid_closure_range_pow {n : ℕ} (hn : Even n) :
    closure (range fun x : ℤ ↦ x ^ n) = nonneg _ 
goal: AddSubmonoid.closure (Set.range fun x => x ^ n) = AddSubmonoid.nonneg ℤ

full_name: Int.addSubmonoid_closure_range_mul_self
code: @[simp]
lemma addSubmonoid_closure_range_mul_self : closure (range fun x : ℤ ↦ x * x) = nonneg _ 
goal: AddSubmonoid.closure (Set.range fun x => x * x) = AddSubmonoid.nonneg ℤ

full_name: Int.instStarOrderedRing
code: instance instStarOrderedRing : StarOrderedRing ℤ 
goal: StarOrderedRing ℤ
File: Mathlib/Data/Int/CharZero.lean

full_name: Int.cast_div_charZero
code: @[simp, norm_cast]
theorem cast_div_charZero {k : Type*} [DivisionRing k] [CharZero k] {m n : ℤ} (n_dvd : n ∣ m) :
    ((m / n : ℤ) : k) = m / n 
goal: ↑(m / n) = ↑m / ↑n

full_name: Int.cast_div_ofNat_charZero
code: @[simp, norm_cast]
theorem cast_div_ofNat_charZero {k : Type*} [DivisionRing k] [CharZero k] {m n : ℕ}
    (n_dvd : n ∣ m) : (((m : ℤ) / (n : ℤ) : ℤ) : k) = m / n 
goal: ↑(↑m / ↑n) = ↑m / ↑n

full_name: RingHom.injective_int
code: theorem RingHom.injective_int {α : Type*} [NonAssocRing α] (f : ℤ →+* α) [CharZero α] :
    Function.Injective f 
goal: Function.Injective ⇑f

full_name: Function.support_intCast
code: lemma support_intCast (hn : n ≠ 0) : support (n : α → β) = univ 
goal: Function.support ↑n = Set.univ

full_name: Function.mulSupport_intCast
code: lemma mulSupport_intCast (hn : n ≠ 1) : mulSupport (n : α → β) = univ 
goal: Function.mulSupport ↑n = Set.univ
File: Mathlib/Data/Int/Sqrt.lean

full_name: Int.sqrt
code: /-- `sqrt z` is the square root of an integer `z`. If `z` is positive, it returns the largest
integer `r` such that `r * r ≤ n`. If it is negative, it returns `0`. For example, `sqrt (-1) = 0`,
`sqrt 1 = 1`, `sqrt 2 = 1` -/
@[pp_nodot]
def sqrt (z : ℤ) : ℤ 
goal: ℤ

full_name: Int.sqrt_eq
code: theorem sqrt_eq (n : ℤ) : sqrt (n * n) = n.natAbs 
goal: Int.sqrt (n * n) = ↑n.natAbs

full_name: Int.exists_mul_self
code: theorem exists_mul_self (x : ℤ) : (∃ n, n * n = x) ↔ sqrt x * sqrt x = x 
goal: (∃ n, n * n = x) ↔ Int.sqrt x * Int.sqrt x = x

full_name: Int.sqrt_nonneg
code: theorem sqrt_nonneg (n : ℤ) : 0 ≤ sqrt n 
goal: 0 ≤ Int.sqrt n

full_name: Int.sqrt_natCast
code: @[simp, norm_cast]
theorem sqrt_natCast (n : ℕ) : Int.sqrt (n : ℤ) = Nat.sqrt n 
goal: Int.sqrt ↑n = ↑n.sqrt

full_name: Int.sqrt_ofNat
code: @[simp]
theorem sqrt_ofNat (n : ℕ) : Int.sqrt (no_index (OfNat.ofNat n) : ℤ) = Nat.sqrt (OfNat.ofNat n) 
goal: Int.sqrt (OfNat.ofNat n) = ↑(Nat.sqrt (OfNat.ofNat n))
File: Mathlib/Data/Int/AbsoluteValue.lean

full_name: AbsoluteValue.map_units_int
code: @[simp]
theorem AbsoluteValue.map_units_int (abv : AbsoluteValue ℤ S) (x : ℤˣ) : abv x = 1 
goal: abv ↑x = 1

full_name: AbsoluteValue.map_units_intCast
code: @[simp]
theorem AbsoluteValue.map_units_intCast [Nontrivial R] (abv : AbsoluteValue R S) (x : ℤˣ) :
    abv ((x : ℤ) : R) = 1 
goal: abv ↑↑x = 1

full_name: AbsoluteValue.map_units_int_smul
code: @[simp]
theorem AbsoluteValue.map_units_int_smul (abv : AbsoluteValue R S) (x : ℤˣ) (y : R) :
    abv (x • y) = abv y 
goal: abv (x • y) = abv y

full_name: Int.natAbsHom
code: /-- `Int.natAbs` as a bundled monoid with zero hom. -/
@[simps]
def Int.natAbsHom : ℤ →*₀ ℕ 
goal: ℤ →*₀ ℕ

full_name: Int.natAbsHom_apply
code: /-- `Int.natAbs` as a bundled monoid with zero hom. -/
@[simps]
def Int.natAbsHom : ℤ →*₀ ℕ 
goal: Int.natAbsHom m = m.natAbs
File: Mathlib/Data/List/Lemmas.lean

full_name: List.injOn_insertNth_index_of_not_mem
code: theorem injOn_insertNth_index_of_not_mem (l : List α) (x : α) (hx : x ∉ l) :
    Set.InjOn (fun k => insertNth k x l) { n | n ≤ l.length } 
goal: Set.InjOn (fun k => List.insertNth k x l) {n | n ≤ l.length}

full_name: List.foldr_range_subset_of_range_subset
code: theorem foldr_range_subset_of_range_subset {f : β → α → α} {g : γ → α → α}
    (hfg : Set.range f ⊆ Set.range g) (a : α) : Set.range (foldr f a) ⊆ Set.range (foldr g a) 
goal: Set.range (List.foldr f a) ⊆ Set.range (List.foldr g a)

full_name: List.foldl_range_subset_of_range_subset
code: theorem foldl_range_subset_of_range_subset {f : α → β → α} {g : α → γ → α}
    (hfg : (Set.range fun a c => f c a) ⊆ Set.range fun b c => g c b) (a : α) :
    Set.range (foldl f a) ⊆ Set.range (foldl g a) 
goal: Set.range (List.foldl f a) ⊆ Set.range (List.foldl g a)

full_name: List.foldr_range_eq_of_range_eq
code: theorem foldr_range_eq_of_range_eq {f : β → α → α} {g : γ → α → α} (hfg : Set.range f = Set.range g)
    (a : α) : Set.range (foldr f a) = Set.range (foldr g a) 
goal: Set.range (List.foldr f a) = Set.range (List.foldr g a)

full_name: List.foldl_range_eq_of_range_eq
code: theorem foldl_range_eq_of_range_eq {f : α → β → α} {g : α → γ → α}
    (hfg : (Set.range fun a c => f c a) = Set.range fun b c => g c b) (a : α) :
    Set.range (foldl f a) = Set.range (foldl g a) 
goal: Set.range (List.foldl f a) = Set.range (List.foldl g a)

full_name: List.mapAccumr_eq_foldr
code: theorem mapAccumr_eq_foldr {σ : Type*} (f : α → σ → σ × β) : ∀ (as : List α) (s : σ),
    mapAccumr f as s = List.foldr (fun a s =>
                                    let r := f a s.1
                                    (r.1, r.2 :: s.2)
                                  ) (s, []) as
  
goal: List.mapAccumr f as s =
  List.foldr
    (fun a s =>
      let r := f a s.1;
      (r.1, r.2 :: s.2))
    (s, []) as

full_name: List.mapAccumr₂_eq_foldr
code: theorem mapAccumr₂_eq_foldr {σ φ : Type*} (f : α → β → σ → σ × φ) :
    ∀ (as : List α) (bs : List β) (s : σ),
    mapAccumr₂ f as bs s = foldr (fun ab s =>
                              let r := f ab.1 ab.2 s.1
                              (r.1, r.2 :: s.2)
                            ) (s, []) (as.zip bs)
  
goal: List.mapAccumr₂ f as bs s =
  List.foldr
    (fun ab s =>
      let r := f ab.1 ab.2 s.1;
      (r.1, r.2 :: s.2))
    (s, []) (as.zip bs)
File: Mathlib/Data/List/GetD.lean

full_name: List.getD_eq_get
code: theorem getD_eq_get {n : ℕ} (hn : n < l.length) : l.getD n d = l.get ⟨n, hn⟩ 
goal: l.getD n d = l.get ⟨n, hn⟩

full_name: List.getD_map
code: theorem getD_map {n : ℕ} (f : α → β) : (map f l).getD n (f d) = f (l.getD n d) 
goal: (List.map f l).getD n (f d) = f (l.getD n d)

full_name: List.getD_eq_default
code: theorem getD_eq_default {n : ℕ} (hn : l.length ≤ n) : l.getD n d = d 
goal: l.getD n d = d

full_name: List.decidableGetDNilNe
code: /-- An empty list can always be decidably checked for the presence of an element.
Not an instance because it would clash with `DecidableEq α`. -/
def decidableGetDNilNe (a : α) : DecidablePred fun i : ℕ => getD ([] : List α) i a ≠ a 
goal: DecidablePred fun i => [].getD i a ≠ a

full_name: List.getElem?_getD_singleton_default_eq
code: @[simp]
theorem getElem?_getD_singleton_default_eq (n : ℕ) : [d][n]?.getD d = d 
goal: [d][n]?.getD d = d

full_name: List.getElem?_getD_replicate_default_eq
code: @[simp]
theorem getElem?_getD_replicate_default_eq (r n : ℕ) : (replicate r d)[n]?.getD d = d 
goal: (List.replicate r d)[n]?.getD d = d

full_name: List.getD_append
code: theorem getD_append (l l' : List α) (d : α) (n : ℕ) (h : n < l.length) :
    (l ++ l').getD n d = l.getD n d 
goal: (l ++ l').getD n d = l.getD n d

full_name: List.getD_append_right
code: theorem getD_append_right (l l' : List α) (d : α) (n : ℕ) (h : l.length ≤ n) :
    (l ++ l').getD n d = l'.getD (n - l.length) d 
goal: (l ++ l').getD n d = l'.getD (n - l.length) d

full_name: List.getD_eq_getD_get?
code: theorem getD_eq_getD_get? (n : ℕ) : l.getD n d = (l.get? n).getD d 
goal: l.getD n d = (l.get? n).getD d

full_name: List.getI_nil
code: @[simp]
theorem getI_nil : getI ([] : List α) n = default 
goal: [].getI n = default

full_name: List.getI_cons_zero
code: @[simp]
theorem getI_cons_zero : getI (x :: xs) 0 = x 
goal: (x :: xs).getI 0 = x

full_name: List.getI_cons_succ
code: @[simp]
theorem getI_cons_succ : getI (x :: xs) (n + 1) = getI xs n 
goal: (x :: xs).getI (n + 1) = xs.getI n

full_name: List.getI_eq_get
code: theorem getI_eq_get {n : ℕ} (hn : n < l.length) : l.getI n = l.get ⟨n, hn⟩ 
goal: l.getI n = l.get ⟨n, hn⟩

full_name: List.getI_eq_default
code: theorem getI_eq_default {n : ℕ} (hn : l.length ≤ n) : l.getI n = default 
goal: l.getI n = default

full_name: List.getD_default_eq_getI
code: theorem getD_default_eq_getI {n : ℕ} : l.getD n default = l.getI n 
goal: l.getD n default = l.getI n

full_name: List.getI_append
code: theorem getI_append (l l' : List α) (n : ℕ) (h : n < l.length) :
    (l ++ l').getI n = l.getI n 
goal: (l ++ l').getI n = l.getI n

full_name: List.getI_append_right
code: theorem getI_append_right (l l' : List α) (n : ℕ) (h : l.length ≤ n) :
    (l ++ l').getI n = l'.getI (n - l.length) 
goal: (l ++ l').getI n = l'.getI (n - l.length)

full_name: List.getI_eq_iget_get?
code: theorem getI_eq_iget_get? (n : ℕ) : l.getI n = (l.get? n).iget 
goal: l.getI n = (l.get? n).iget

full_name: List.getI_zero_eq_headI
code: theorem getI_zero_eq_headI : l.getI 0 = l.headI 
goal: l.getI 0 = l.headI
File: Mathlib/Data/List/Palindrome.lean

full_name: List.Palindrome.nil
code: /-- `Palindrome l` asserts that `l` is a palindrome. This is defined inductively:

* The empty list is a palindrome;
* A list with one element is a palindrome;
* Adding the same element to both ends of a palindrome results in a bigger palindrome.
-/
inductive Palindrome : List α → Prop
  | nil : Palindrome []
  | singleton : ∀ x, Palindrome [x]
  | cons_concat : ∀ (x) {l}, Palindrome l → Palindrome (x :: (l ++ [x]))
goal: [].Palindrome

full_name: List.Palindrome
code: /-- `Palindrome l` asserts that `l` is a palindrome. This is defined inductively:

* The empty list is a palindrome;
* A list with one element is a palindrome;
* Adding the same element to both ends of a palindrome results in a bigger palindrome.
-/
inductive Palindrome : List α → Prop
  | nil : Palindrome []
  | singleton : ∀ x, Palindrome [x]
  | cons_concat : ∀ (x) {l}, Palindrome l → Palindrome (x :: (l ++ [x]))
goal: List α → Prop

full_name: List.Palindrome.cons_concat
code: /-- `Palindrome l` asserts that `l` is a palindrome. This is defined inductively:

* The empty list is a palindrome;
* A list with one element is a palindrome;
* Adding the same element to both ends of a palindrome results in a bigger palindrome.
-/
inductive Palindrome : List α → Prop
  | nil : Palindrome []
  | singleton : ∀ x, Palindrome [x]
  | cons_concat : ∀ (x) {l}, Palindrome l → Palindrome (x :: (l ++ [x]))
goal: l.Palindrome → (x :: (l ++ [x])).Palindrome

full_name: List.Palindrome.singleton
code: /-- `Palindrome l` asserts that `l` is a palindrome. This is defined inductively:

* The empty list is a palindrome;
* A list with one element is a palindrome;
* Adding the same element to both ends of a palindrome results in a bigger palindrome.
-/
inductive Palindrome : List α → Prop
  | nil : Palindrome []
  | singleton : ∀ x, Palindrome [x]
  | cons_concat : ∀ (x) {l}, Palindrome l → Palindrome (x :: (l ++ [x]))
goal: [x].Palindrome

full_name: List.Palindrome.reverse_eq
code: theorem reverse_eq {l : List α} (p : Palindrome l) : reverse l = l 
goal: l.reverse = l

full_name: List.Palindrome.of_reverse_eq
code: theorem of_reverse_eq {l : List α} : reverse l = l → Palindrome l 
goal: l.reverse = l → l.Palindrome

full_name: List.Palindrome.iff_reverse_eq
code: theorem iff_reverse_eq {l : List α} : Palindrome l ↔ reverse l = l 
goal: l.Palindrome ↔ l.reverse = l

full_name: List.Palindrome.append_reverse
code: theorem append_reverse (l : List α) : Palindrome (l ++ reverse l) 
goal: (l ++ l.reverse).Palindrome

full_name: List.Palindrome.map
code: protected theorem map (f : α → β) (p : Palindrome l) : Palindrome (map f l) 
goal: (List.map f l).Palindrome

full_name: List.Palindrome.instDecidableOfDecidableEq
code: instance [DecidableEq α] (l : List α) : Decidable (Palindrome l) 
goal: Decidable l.Palindrome
File: Mathlib/Data/List/Sections.lean

full_name: List.mem_sections
code: theorem mem_sections {L : List (List α)} {f} : f ∈ sections L ↔ Forall₂ (· ∈ ·) f L 
goal: f ∈ L.sections ↔ List.Forall₂ (fun x x_1 => x ∈ x_1) f L

full_name: List.mem_sections_length
code: theorem mem_sections_length {L : List (List α)} {f} (h : f ∈ sections L) : length f = length L 
goal: f.length = L.length

full_name: List.rel_sections
code: theorem rel_sections {r : α → β → Prop} :
    (Forall₂ (Forall₂ r) ⇒ Forall₂ (Forall₂ r)) sections sections
  
goal: (List.Forall₂ (List.Forall₂ r) ⇒ List.Forall₂ (List.Forall₂ r)) List.sections List.sections
File: Mathlib/Data/List/Iterate.lean

full_name: List.length_iterate
code: @[simp]
theorem length_iterate (f : α → α) (a : α) (n : ℕ) : length (iterate f a n) = n 
goal: (List.iterate f a n).length = n

full_name: List.iterate_eq_nil
code: @[simp]
theorem iterate_eq_nil {f : α → α} {a : α} {n : ℕ} : iterate f a n = [] ↔ n = 0 
goal: List.iterate f a n = [] ↔ n = 0

full_name: List.getElem?_iterate
code: theorem getElem?_iterate (f : α → α) (a : α) :
    ∀ (n i : ℕ), i < n → (iterate f a n)[i]? = f^[i] a
  
goal: i < n → (List.iterate f a n)[i]? = some (f^[i] a)

full_name: List.get?_iterate
code: theorem get?_iterate (f : α → α) (a : α) (n i : ℕ) (h : i < n) :
    get? (iterate f a n) i = f^[i] a 
goal: (List.iterate f a n).get? i = some (f^[i] a)

full_name: List.getElem_iterate
code: @[simp]
theorem getElem_iterate (f : α → α) (a : α) (n : ℕ) (i : Nat) (h : i < (iterate f a n).length) :
    (iterate f a n)[i] = f^[↑i] a 
goal: (List.iterate f a n)[i] = f^[i] a

full_name: List.get_iterate
code: theorem get_iterate (f : α → α) (a : α) (n : ℕ) (i : Fin (iterate f a n).length) :
    get (iterate f a n) i = f^[↑i] a 
goal: (List.iterate f a n).get i = f^[↑i] a

full_name: List.mem_iterate
code: @[simp]
theorem mem_iterate {f : α → α} {a : α} {n : ℕ} {b : α} :
    b ∈ iterate f a n ↔ ∃ m < n, b = f^[m] a 
goal: b ∈ List.iterate f a n ↔ ∃ m < n, b = f^[m] a

full_name: List.range_map_iterate
code: @[simp]
theorem range_map_iterate (n : ℕ) (f : α → α) (a : α) :
    (List.range n).map (f^[·] a) = List.iterate f a n 
goal: List.map (fun x => f^[x] a) (List.range n) = List.iterate f a n

full_name: List.iterate_add
code: theorem iterate_add (f : α → α) (a : α) (m n : ℕ) :
    iterate f a (m + n) = iterate f a m ++ iterate f (f^[m] a) n 
goal: List.iterate f a (m + n) = List.iterate f a m ++ List.iterate f (f^[m] a) n

full_name: List.take_iterate
code: theorem take_iterate (f : α → α) (a : α) (m n : ℕ) :
    take m (iterate f a n) = iterate f a (min m n) 
goal: List.take m (List.iterate f a n) = List.iterate f a (min m n)