ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: .lake/packages/lean4/src/lean/Init/Data/Hashable.lean

full_name: «instHashableNat_.lake»
code: instance : Hashable Nat 
goal: Hashable Nat

full_name: «instHashablePos_.lake»
code: instance : Hashable String.Pos 
goal: Hashable String.Pos

full_name: «instHashableProd_.lake»
code: instance [Hashable α] [Hashable β] : Hashable (α × β) 
goal: Hashable (α × β)

full_name: «instHashableBool_.lake»
code: instance : Hashable Bool 
goal: Hashable Bool

full_name: «instHashableOption_.lake»
code: instance [Hashable α] : Hashable (Option α) 
goal: Hashable (Option α)

full_name: «instHashableList_.lake»
code: instance [Hashable α] : Hashable (List α) 
goal: Hashable (List α)

full_name: «instHashableArray_.lake»
code: instance [Hashable α] : Hashable (Array α) 
goal: Hashable (Array α)

full_name: «instHashableUInt8_.lake»
code: instance : Hashable UInt8 
goal: Hashable UInt8

full_name: «instHashableUInt16_.lake»
code: instance : Hashable UInt16 
goal: Hashable UInt16

full_name: «instHashableUInt32_.lake»
code: instance : Hashable UInt32 
goal: Hashable UInt32

full_name: «instHashableUInt64_.lake»
code: instance : Hashable UInt64 
goal: Hashable UInt64

full_name: «instHashableUSize_.lake»
code: instance : Hashable USize 
goal: Hashable USize

full_name: «instHashableFin_.lake»
code: instance : Hashable (Fin n) 
goal: Hashable (Fin n)

full_name: «instHashableInt_.lake»
code: instance : Hashable Int 
goal: Hashable Int

full_name: «instHashable_.lake»
code: instance (P : Prop) : Hashable P 
goal: Hashable P

full_name: hash64
code: /-- An opaque (low-level) hash operation used to implement hashing for pointers. -/
@[always_inline, inline] def hash64 (u : UInt64) : UInt64 
goal: UInt64
File: .lake/packages/lean4/src/lean/Init/Data/Int/Bitwise/Lemmas.lean

full_name: Int.shiftRight_eq
code: theorem shiftRight_eq (n : Int) (s : Nat) : n >>> s = Int.shiftRight n s 
goal: n >>> s = n.shiftRight s

full_name: Int.natCast_shiftRight
code: @[simp]
theorem natCast_shiftRight (n s : Nat) : (n : Int) >>> s = n >>> s 
goal: ↑n >>> s = ↑(n >>> s)

full_name: Int.negSucc_shiftRight
code: @[simp]
theorem negSucc_shiftRight (m n : Nat) :
    -[m+1] >>> n = -[m >>>n +1] 
goal: Int.negSucc m >>> n = Int.negSucc (m >>> n)

full_name: Int.shiftRight_add
code: theorem shiftRight_add (i : Int) (m n : Nat) :
    i >>> (m + n) = i >>> m >>> n 
goal: i >>> (m + n) = i >>> m >>> n

full_name: Int.shiftRight_eq_div_pow
code: theorem shiftRight_eq_div_pow (m : Int) (n : Nat) :
    m >>> n = m / ((2 ^ n) : Nat) 
goal: m >>> n = m / ↑(2 ^ n)

full_name: Int.zero_shiftRight
code: @[simp]
theorem zero_shiftRight (n : Nat) : (0 : Int) >>> n = 0 
goal: 0 >>> n = 0
File: .lake/packages/lean4/src/lean/Init/Data/Int/Bitwise.lean

full_name: Int.not
code: /--
Bitwise not

Interprets the integer as an infinite sequence of bits in two's complement
and complements each bit.
```
~~~(0:Int) = -1
~~~(1:Int) = -2
~~~(-1:Int) = 0
```
-/
protected def not : Int -> Int
  
goal: Int → Int

full_name: Int.«instComplement_.lake»
code: instance : Complement Int 
goal: Complement Int

full_name: Int.shiftRight
code: /--
Bitwise shift right.

Conceptually, this treats the integer as an infinite sequence of bits in two's
complement and shifts the value to the right.

```lean
( 0b0111:Int) >>> 1 =  0b0011
( 0b1000:Int) >>> 1 =  0b0100
(-0b1000:Int) >>> 1 = -0b0100
(-0b0111:Int) >>> 1 = -0b0100
```
-/
protected def shiftRight : Int → Nat → Int
  
goal: Int → Nat → Int

full_name: Int.«instHShiftRightNat_.lake»
code: instance : HShiftRight Int Nat Int 
goal: HShiftRight Int Nat Int
File: .lake/packages/lean4/src/lean/Init/Data/Int/Pow.lean

full_name: Int.pow_zero
code: protected theorem pow_zero (b : Int) : b^0 = 1 
goal: b ^ 0 = 1

full_name: Int.pow_succ
code: protected theorem pow_succ (b : Int) (e : Nat) : b ^ (e+1) = (b ^ e) * b 
goal: b ^ (e + 1) = b ^ e * b

full_name: Int.pow_succ'
code: protected theorem pow_succ' (b : Int) (e : Nat) : b ^ (e+1) = b * (b ^ e) 
goal: b ^ (e + 1) = b * b ^ e

full_name: Int.pow_le_pow_of_le_left
code: theorem pow_le_pow_of_le_left {n m : Nat} (h : n ≤ m) : ∀ (i : Nat), n^i ≤ m^i
  
goal: n ^ i ≤ m ^ i

full_name: Int.pow_le_pow_of_le_right
code: theorem pow_le_pow_of_le_right {n : Nat} (hx : n > 0) {i : Nat} : ∀ {j}, i ≤ j → n^i ≤ n^j
  
goal: i ≤ j → n ^ i ≤ n ^ j

full_name: Int.pos_pow_of_pos
code: theorem pos_pow_of_pos {n : Nat} (m : Nat) (h : 0 < n) : 0 < n^m 
goal: 0 < n ^ m

full_name: Int.natCast_pow
code: theorem natCast_pow (b n : Nat) : ((b^n : Nat) : Int) = (b : Int) ^ n 
goal: ↑(b ^ n) = ↑b ^ n
File: .lake/packages/lean4/src/lean/Init/Data/Int/Gcd.lean

full_name: Int.gcd
code: /-- Computes the greatest common divisor of two integers, as a `Nat`. -/
def gcd (m n : Int) : Nat 
goal: Nat

full_name: Int.gcd_dvd_left
code: theorem gcd_dvd_left {a b : Int} : (gcd a b : Int) ∣ a 
goal: ↑(a.gcd b) ∣ a

full_name: Int.gcd_dvd_right
code: theorem gcd_dvd_right {a b : Int} : (gcd a b : Int) ∣ b 
goal: ↑(a.gcd b) ∣ b

full_name: Int.one_gcd
code: @[simp] theorem one_gcd {a : Int} : gcd 1 a = 1 
goal: Int.gcd 1 a = 1

full_name: Int.gcd_one
code: @[simp] theorem gcd_one {a : Int} : gcd a 1 = 1 
goal: a.gcd 1 = 1

full_name: Int.neg_gcd
code: @[simp] theorem neg_gcd {a b : Int} : gcd (-a) b = gcd a b 
goal: (-a).gcd b = a.gcd b

full_name: Int.gcd_neg
code: @[simp] theorem gcd_neg {a b : Int} : gcd a (-b) = gcd a b 
goal: a.gcd (-b) = a.gcd b

full_name: Int.lcm
code: /-- Computes the least common multiple of two integers, as a `Nat`. -/
def lcm (m n : Int) : Nat 
goal: Nat

full_name: Int.lcm_ne_zero
code: theorem lcm_ne_zero (hm : m ≠ 0) (hn : n ≠ 0) : lcm m n ≠ 0 
goal: m.lcm n ≠ 0

full_name: Int.dvd_lcm_left
code: theorem dvd_lcm_left {a b : Int} : a ∣ lcm a b 
goal: a ∣ ↑(a.lcm b)

full_name: Int.dvd_lcm_right
code: theorem dvd_lcm_right {a b : Int} : b ∣ lcm a b 
goal: b ∣ ↑(a.lcm b)

full_name: Int.lcm_self
code: @[simp] theorem lcm_self {a : Int} : lcm a a = a.natAbs 
goal: a.lcm a = a.natAbs
File: .lake/packages/lean4/src/lean/Init/Data/Stream.lean

full_name: ToStream
code: /--
  Streams are used to implement parallel `for` statements.
  Example:
  ```
  for x in xs, y in ys do
    ...
  ```
  is expanded into
  ```
  let mut s := toStream ys
  for x in xs do
    match Stream.next? s with
    | none => break
    | some (y, s') =>
      s := s'
      ...
  ```
-/
class ToStream (collection : Type u) (stream : outParam (Type u)) : Type u where
  toStream : collection → stream
goal: Type u

full_name: ToStream.toStream
code: /--
  Streams are used to implement parallel `for` statements.
  Example:
  ```
  for x in xs, y in ys do
    ...
  ```
  is expanded into
  ```
  let mut s := toStream ys
  for x in xs do
    match Stream.next? s with
    | none => break
    | some (y, s') =>
      s := s'
      ...
  ```
-/
class ToStream (collection : Type u) (stream : outParam (Type u)) : Type u where
  toStream : collection → stream
goal: collection → stream

full_name: Stream
code: class Stream (stream : Type u) (value : outParam (Type v)) : Type (max u v) where
  next? : stream → Option (value × stream)
goal: Type (max u v)

full_name: Stream.next?
code: class Stream (stream : Type u) (value : outParam (Type v)) : Type (max u v) where
  next? : stream → Option (value × stream)
goal: stream → Option (value × stream)

full_name: Stream.forIn.visit
code: protected partial def Stream.forIn [Stream ρ α] [Monad m] (s : ρ) (b : β) (f : α → β → m (ForInStep β)) : m β 
goal: m β

full_name: Stream.forIn
code: protected partial def Stream.forIn [Stream ρ α] [Monad m] (s : ρ) (b : β) (f : α → β → m (ForInStep β)) : m β 
goal: m β

full_name: instForInOfStream
code: instance (priority := low) [Stream ρ α] : ForIn m ρ α 
goal: ForIn m ρ α

full_name: instToStreamList
code: instance : ToStream (List α) (List α) 
goal: ToStream (List α) (List α)

full_name: instToStreamArraySubarray
code: instance : ToStream (Array α) (Subarray α) 
goal: ToStream (Array α) (Subarray α)

full_name: instToStreamSubarray
code: instance : ToStream (Subarray α) (Subarray α) 
goal: ToStream (Subarray α) (Subarray α)

full_name: instToStreamStringSubstring
code: instance : ToStream String Substring 
goal: ToStream String Substring

full_name: instToStreamRange
code: instance : ToStream Std.Range Std.Range 
goal: ToStream Std.Range Std.Range

full_name: instStreamProd
code: instance [Stream ρ α] [Stream γ β] : Stream (ρ × γ) (α × β) 
goal: Stream (ρ × γ) (α × β)

full_name: instStreamList
code: instance : Stream (List α) α 
goal: Stream (List α) α

full_name: instStreamSubarray
code: instance : Stream (Subarray α) α 
goal: Stream (Subarray α) α

full_name: instStreamRangeNat
code: instance : Stream Std.Range Nat 
goal: Stream Std.Range Nat

full_name: instStreamSubstringChar
code: instance : Stream Substring Char 
goal: Stream Substring Char
File: .lake/packages/lean4/src/lean/Init/Data/List/Notation.lean

full_name: «term[_]»
code: /--
The syntax `[a, b, c]` is shorthand for `a :: b :: c :: []`, or
`List.cons a (List.cons b (List.cons c List.nil))`. It allows conveniently constructing
list literals.

For lists of length at least 64, an alternative desugaring strategy is used
which uses let bindings as intermediates as in
`let left := [d, e, f]; a :: b :: c :: left` to avoid creating very deep expressions.
Note that this changes the order of evaluation, although it should not be observable
unless you use side effecting operations like `dbg_trace`.
-/
syntax "[" withoutPosition(term,*,?) "]"  : term
goal: Lean.ParserDescr

full_name: «term%[_|_]»
code: /--
Auxiliary syntax for implementing `[$elem,*]` list literal syntax.
The syntax `%[a,b,c|tail]` constructs a value equivalent to `a::b::c::tail`.
It uses binary partitioning to construct a tree of intermediate let bindings as in
`let left := [d, e, f]; a :: b :: c :: left` to avoid creating very deep expressions.
-/
syntax "%[" withoutPosition(term,*,? " | " term) "]" : term
goal: Lean.ParserDescr

full_name: Lean.«_aux_.lake_packages_lean4_src_lean_Init_Data_List_Notation___macroRules_term[_]_1»
code: macro_rules
  | `([ $elems,* ]) => do
    -- NOTE: we do not have `TSepArray.getElems` yet at this point
    let rec expandListLit (i : Nat) (skip : Bool) (result : TSyntax `term) : MacroM Syntax := do
      match i, skip with
      | 0,   _     => pure result
      | i+1, true  => expandListLit i false result
      | i+1, false => expandListLit i true  (← ``(List.cons $(⟨elems.elemsAndSeps.get! i⟩) $result))
    let size := elems.elemsAndSeps.size
    if size < 64 then
      expandListLit size (size % 2 == 0) (← ``(List.nil))
    else
      `(%[ $elems,* | List.nil ])
goal: Lean.Macro

full_name: Lean.«_aux_.lake_packages_lean4_src_lean_Init_Data_List_Notation___macroRules_term[_]_1».expandListLit
code: macro_rules
  | `([ $elems,* ]) => do
    -- NOTE: we do not have `TSepArray.getElems` yet at this point
    let rec expandListLit (i : Nat) (skip : Bool) (result : TSyntax `term) : MacroM Syntax := do
      match i, skip with
      | 0,   _     => pure result
      | i+1, true  => expandListLit i false result
      | i+1, false => expandListLit i true  (← ``(List.cons $(⟨elems.elemsAndSeps.get! i⟩) $result))
    let size := elems.elemsAndSeps.size
    if size < 64 then
      expandListLit size (size % 2 == 0) (← ``(List.nil))
    else
      `(%[ $elems,* | List.nil ])
goal: Lean.MacroM Lean.Syntax
File: .lake/packages/lean4/src/lean/Init/Data/Format/Instances.lean

full_name: «instToFormatOfToString_.lake»
code: instance (priority := low) [ToString α] : ToFormat α 
goal: Std.ToFormat α

full_name: List.format
code: def List.format [ToFormat α] : List α → Format
  
goal: List α → Std.Format

full_name: «instToFormatList_.lake»
code: instance [ToFormat α] : ToFormat (List α) 
goal: Std.ToFormat (List α)

full_name: «instToFormatArray_.lake»
code: instance [ToFormat α] : ToFormat (Array α) 
goal: Std.ToFormat (Array α)

full_name: Option.format
code: def Option.format {α : Type u} [ToFormat α] : Option α → Format
  
goal: Option α → Std.Format

full_name: «instToFormatOption_.lake»
code: instance {α : Type u} [ToFormat α] : ToFormat (Option α) 
goal: Std.ToFormat (Option α)

full_name: «instToFormatProd_.lake»
code: instance {α : Type u} {β : Type v} [ToFormat α] [ToFormat β] : ToFormat (Prod α β) 
goal: Std.ToFormat (α × β)

full_name: String.toFormat
code: def String.toFormat (s : String) : Std.Format 
goal: Std.Format

full_name: «instToFormatPos_.lake»
code: instance : ToFormat String.Pos 
goal: Std.ToFormat String.Pos
File: .lake/packages/lean4/src/lean/Init/Data/Format/Syntax.lean

full_name: _private.«.lake».packages.lean4.src.lean.Init.Data.Format.Syntax.0.Lean.Syntax.formatInfo
code: private def formatInfo (showInfo : Bool) (info : SourceInfo) (f : Format) : Format 
goal: Std.Format

full_name: Lean.Syntax.formatStxAux
code: partial def formatStxAux (maxDepth : Option Nat) (showInfo : Bool) (depth : Nat) : Syntax → Format
  
goal: Lean.Syntax → Std.Format

full_name: Lean.Syntax.formatStx
code: /-- Pretty print the given syntax `stx` as a `Format`.
Nodes deeper than `maxDepth` are omitted.
Setting the `showInfo` flag will also print the `SourceInfo` for each node. -/
def formatStx (stx : Syntax) (maxDepth : Option Nat := none) (showInfo := false) : Format 
goal: Std.Format

full_name: Lean.Syntax.«instToFormat_.lake»
code: instance : ToFormat (Syntax) 
goal: Std.ToFormat Lean.Syntax

full_name: Lean.Syntax.«instToString_.lake»
code: instance : ToString (Syntax) 
goal: ToString Lean.Syntax

full_name: Lean.Syntax.«instToFormatTSyntax_.lake»
code: instance : ToFormat (TSyntax k) 
goal: Std.ToFormat (Lean.TSyntax k)

full_name: Lean.Syntax.«instToStringTSyntax_.lake»
code: instance : ToString (TSyntax k) 
goal: ToString (Lean.TSyntax k)
File: .lake/packages/lean4/src/lean/Init/Data/Format/Macro.lean

full_name: Std.termF!_
code: syntax:max "f!" interpolatedStr(term) : term
goal: Lean.ParserDescr

full_name: Std.«_aux_.lake_packages_lean4_src_lean_Init_Data_Format_Macro___macroRules_Std_termF!__1»
code: macro_rules
  | `(f! $interpStr) => do interpStr.expandInterpolatedStr (← `(Format)) (← `(Std.format))
goal: Lean.Macro
File: .lake/packages/lean4/src/lean/Init/Data/Cast.lean

full_name: NatCast.natCast
code: /-- Type class for the canonical homomorphism `Nat → R`. -/
class NatCast (R : Type u) where
  /-- The canonical map `Nat → R`. -/
  protected natCast : Nat → R
goal: Nat → R

full_name: NatCast
code: /-- Type class for the canonical homomorphism `Nat → R`. -/
class NatCast (R : Type u) where
  /-- The canonical map `Nat → R`. -/
  protected natCast : Nat → R
goal: Type u

full_name: instNatCastNat
code: instance : NatCast Nat 
goal: NatCast Nat

full_name: Nat.cast
code: /--
Canonical homomorphism from `Nat` to a type `R`.

It contains just the function, with no axioms.
In practice, the target type will likely have a (semi)ring structure,
and this homomorphism should be a ring homomorphism.

The prototypical example is `Int.ofNat`.

This class and `IntCast` exist to allow different libraries with their own types that can be notated as natural numbers to have consistent `simp` normal forms without needing to create coercion simplification sets that are aware of all combinations. Libraries should make it easy to work with `NatCast` where possible. For instance, in Mathlib there will be such a homomorphism (and thus a `NatCast R` instance) whenever `R` is an additive monoid with a `1`.
-/
@[coe, reducible, match_pattern] protected def Nat.cast {R : Type u} [NatCast R] : Nat → R 
goal: Nat → R

full_name: instCoeTailNatOfNatCast
code: instance [NatCast R] : CoeTail Nat R 
goal: CoeTail Nat R

full_name: instCoeHTCTNatOfNatCast
code: instance [NatCast R] : CoeHTCT Nat R 
goal: CoeHTCT Nat R
File: .lake/packages/lean4/src/lean/Init/Data/Prod.lean

full_name: «instLawfulBEqProd_.lake»
code: instance [BEq α] [BEq β] [LawfulBEq α] [LawfulBEq β] : LawfulBEq (α × β) 
goal: LawfulBEq (α × β)
File: .lake/packages/lean4/src/lean/Init/Data/UInt/Log2.lean

full_name: UInt8.log2
code: @[extern "lean_uint8_log2"]
def UInt8.log2 (a : UInt8) : UInt8 
goal: UInt8

full_name: UInt16.log2
code: @[extern "lean_uint16_log2"]
def UInt16.log2 (a : UInt16) : UInt16 
goal: UInt16

full_name: UInt32.log2
code: @[extern "lean_uint32_log2"]
def UInt32.log2 (a : UInt32) : UInt32 
goal: UInt32

full_name: UInt64.log2
code: @[extern "lean_uint64_log2"]
def UInt64.log2 (a : UInt64) : UInt64 
goal: UInt64

full_name: USize.log2
code: @[extern "lean_usize_log2"]
def USize.log2 (a : USize) : USize 
goal: USize
File: .lake/packages/lean4/src/lean/Init/Data/ToString/Macro.lean

full_name: termS!_
code: syntax:max "s!" interpolatedStr(term) : term
goal: Lean.ParserDescr

full_name: «_aux_.lake_packages_lean4_src_lean_Init_Data_ToString_Macro___macroRules_termS!__1»
code: macro_rules
  | `(s! $interpStr) => do interpStr.expandInterpolatedStr (← `(String)) (← `(toString))
goal: Lean.Macro
File: .lake/packages/lean4/src/lean/Init/Data/Option/BasicAux.lean

full_name: Option.get!
code: @[inline] def get! {α : Type u} [Inhabited α] : Option α → α
  
goal: Option α → α
File: .lake/packages/lean4/src/lean/Init/Data/Fin/Fold.lean

full_name: Fin.foldl.loop
code: /-- Folds over `Fin n` from the left: `foldl 3 f x = f (f (f x 0) 1) 2`. -/
@[inline] def foldl (n) (f : α → Fin n → α) (init : α) : α 
goal: α

full_name: Fin.foldl
code: /-- Folds over `Fin n` from the left: `foldl 3 f x = f (f (f x 0) 1) 2`. -/
@[inline] def foldl (n) (f : α → Fin n → α) (init : α) : α 
goal: α

full_name: Fin.foldr.loop
code: /-- Folds over `Fin n` from the right: `foldr 3 f x = f 0 (f 1 (f 2 x))`. -/
@[inline] def foldr (n) (f : Fin n → α → α) (init : α) : α 
goal: { i // i ≤ n } → α → α

full_name: Fin.foldr
code: /-- Folds over `Fin n` from the right: `foldr 3 f x = f 0 (f 1 (f 2 x))`. -/
@[inline] def foldr (n) (f : Fin n → α → α) (init : α) : α 
goal: α
File: .lake/packages/lean4/src/lean/Init/Data/Fin/Log2.lean

full_name: Fin.log2
code: def Fin.log2 (n : Fin m) : Fin m 
goal: Fin m
File: .lake/packages/lean4/src/lean/Init/Data/Fin/Iterate.lean

full_name: Fin.hIterateFrom
code: /--
`hIterateFrom f i bnd a` applies `f` over indices `[i:n]` to compute `P n`
from `P i`.

See `hIterate` below for more details.
-/
def hIterateFrom (P : Nat → Sort _) {n} (f : ∀(i : Fin n), P i.val → P (i.val+1))
      (i : Nat) (ubnd : i ≤ n) (a : P i) : P n 
goal: P n

full_name: Fin.hIterate
code: /--
`hIterate` is a heterogenous iterative operation that applies a
index-dependent function `f` to a value `init : P start` a total of
`stop - start` times to produce a value of type `P stop`.

Concretely, `hIterate start stop f init` is equal to
```lean
  init |> f start _ |> f (start+1) _ ... |> f (end-1) _
```

Because it is heterogenous and must return a value of type `P stop`,
`hIterate` requires proof that `start ≤ stop`.

One can prove properties of `hIterate` using the general theorem
`hIterate_elim` or other more specialized theorems.
 -/
def hIterate (P : Nat → Sort _) {n : Nat} (init : P 0) (f : ∀(i : Fin n), P i.val → P (i.val+1)) :
    P n 
goal: P n

full_name: _private.«.lake».packages.lean4.src.lean.Init.Data.Fin.Iterate.0.Fin.hIterateFrom_elim
code: private theorem hIterateFrom_elim {P : Nat → Sort _}(Q : ∀(i : Nat), P i → Prop)
    {n  : Nat}
    (f : ∀(i : Fin n), P i.val → P (i.val+1))
    {i : Nat} (ubnd : i ≤ n)
    (s : P i)
    (init : Q i s)
    (step : ∀(k : Fin n) (s : P k.val), Q k.val s → Q (k.val+1) (f k s)) :
    Q n (hIterateFrom P f i ubnd s) 
goal: Q n (Fin.hIterateFrom P f i ubnd s)

full_name: Fin.hIterate_elim
code: theorem hIterate_elim {P : Nat → Sort _} (Q : ∀(i : Nat), P i → Prop)
    {n : Nat} (f : ∀(i : Fin n), P i.val → P (i.val+1)) (s : P 0) (init : Q 0 s)
    (step : ∀(k : Fin n) (s : P k.val), Q k.val s → Q (k.val+1) (f k s)) :
    Q n (hIterate P s f) 
goal: Q n (Fin.hIterate P s f)

full_name: Fin.hIterate_eq
code: theorem hIterate_eq {P : Nat → Sort _} (state : ∀(i : Nat), P i)
    {n : Nat} (f : ∀(i : Fin n), P i.val → P (i.val+1)) (s : P 0)
    (init : s = state 0)
    (step : ∀(i : Fin n), f i (state i) = state (i+1)) :
    hIterate P s f = state n 
goal: Fin.hIterate P s f = state n
File: .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Basic.lean

full_name: Nat.bitwise_rec_lemma
code: theorem bitwise_rec_lemma {n : Nat} (hNe : n ≠ 0) : n / 2 < n 
goal: n / 2 < n

full_name: Nat.bitwise
code: def bitwise (f : Bool → Bool → Bool) (n m : Nat) : Nat 
goal: Nat

full_name: Nat.land
code: @[extern "lean_nat_land"]
def land : @& Nat → @& Nat → Nat 
goal: Nat → Nat → Nat

full_name: Nat.lor
code: @[extern "lean_nat_lor"]
def lor  : @& Nat → @& Nat → Nat 
goal: Nat → Nat → Nat

full_name: Nat.xor
code: @[extern "lean_nat_lxor"]
def xor  : @& Nat → @& Nat → Nat 
goal: Nat → Nat → Nat

full_name: Nat.shiftLeft
code: @[extern "lean_nat_shiftl"]
def shiftLeft : @& Nat → @& Nat → Nat
  
goal: Nat → Nat → Nat

full_name: Nat.shiftRight
code: @[extern "lean_nat_shiftr"]
def shiftRight : @& Nat → @& Nat → Nat
  
goal: Nat → Nat → Nat

full_name: Nat.«instAndOp_.lake»
code: instance : AndOp Nat 
goal: AndOp Nat

full_name: Nat.«instOrOp_.lake»
code: instance : OrOp Nat 
goal: OrOp Nat

full_name: Nat.«instXor_.lake»
code: instance : Xor Nat 
goal: Xor Nat

full_name: Nat.«instShiftLeft_.lake»
code: instance : ShiftLeft Nat 
goal: ShiftLeft Nat

full_name: Nat.«instShiftRight_.lake»
code: instance : ShiftRight Nat 
goal: ShiftRight Nat

full_name: Nat.shiftLeft_eq
code: theorem shiftLeft_eq (a b : Nat) : a <<< b = a * 2 ^ b 
goal: a <<< b = a * 2 ^ b

full_name: Nat.shiftRight_zero
code: @[simp] theorem shiftRight_zero : n >>> 0 = n 
goal: n >>> 0 = n

full_name: Nat.shiftRight_succ
code: theorem shiftRight_succ (m n) : m >>> (n + 1) = (m >>> n) / 2 
goal: m >>> (n + 1) = m >>> n / 2

full_name: Nat.shiftRight_add
code: theorem shiftRight_add (m n : Nat) : ∀ k, m >>> (n + k) = (m >>> n) >>> k
  
goal: m >>> (n + k) = m >>> n >>> k

full_name: Nat.shiftRight_eq_div_pow
code: theorem shiftRight_eq_div_pow (m : Nat) : ∀ n, m >>> n = m / 2 ^ n
  
goal: m >>> n = m / 2 ^ n

full_name: Nat.testBit
code: /-- `testBit m n` returns whether the `(n+1)` least significant bit is `1` or `0`-/
def testBit (m n : Nat) : Bool 
goal: Bool
File: .lake/packages/lean4/src/lean/Init/Data/Nat/MinMax.lean

full_name: Nat.min_eq_min
code: protected theorem min_eq_min (a : Nat) : Nat.min a b = min a b 
goal: a.min b = min a b

full_name: Nat.min_comm
code: protected theorem min_comm (a b : Nat) : min a b = min b a 
goal: min a b = min b a

full_name: Nat.«instCommutativeMin_.lake»
code: instance : Std.Commutative (α := Nat) min 
goal: Std.Commutative min

full_name: Nat.min_le_right
code: protected theorem min_le_right (a b : Nat) : min a b ≤ b 
goal: min a b ≤ b

full_name: Nat.min_le_left
code: protected theorem min_le_left (a b : Nat) : min a b ≤ a 
goal: min a b ≤ a

full_name: Nat.min_eq_left
code: protected theorem min_eq_left {a b : Nat} (h : a ≤ b) : min a b = a 
goal: min a b = a

full_name: Nat.min_eq_right
code: protected theorem min_eq_right {a b : Nat} (h : b ≤ a) : min a b = b 
goal: min a b = b

full_name: Nat.le_min_of_le_of_le
code: protected theorem le_min_of_le_of_le {a b c : Nat} : a ≤ b → a ≤ c → a ≤ min b c 
goal: a ≤ b → a ≤ c → a ≤ min b c

full_name: Nat.le_min
code: protected theorem le_min {a b c : Nat} : a ≤ min b c ↔ a ≤ b ∧ a ≤ c 
goal: a ≤ min b c ↔ a ≤ b ∧ a ≤ c

full_name: Nat.lt_min
code: protected theorem lt_min {a b c : Nat} : a < min b c ↔ a < b ∧ a < c 
goal: a < min b c ↔ a < b ∧ a < c

full_name: Nat.max_eq_max
code: protected theorem max_eq_max (a : Nat) : Nat.max a b = max a b 
goal: a.max b = max a b

full_name: Nat.max_comm
code: protected theorem max_comm (a b : Nat) : max a b = max b a 
goal: max a b = max b a

full_name: Nat.«instCommutativeMax_.lake»
code: instance : Std.Commutative (α := Nat) max 
goal: Std.Commutative max

full_name: Nat.le_max_left
code: protected theorem le_max_left ( a b : Nat) : a ≤ max a b 
goal: a ≤ max a b

full_name: Nat.le_max_right
code: protected theorem le_max_right (a b : Nat) : b ≤ max a b 
goal: b ≤ max a b