ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Nat.le_of_lt_succ
theorem Nat.le_of_lt_succ {m n : Nat} : LT.lt m (succ n) → LE.le m n 
Arguments: {m n : Nat}
Goal: LT.lt m n.succ → LE.le m n
-- Nat.eq_or_lt_of_le
protected theorem Nat.eq_or_lt_of_le : {n m: Nat} → LE.le n m → Or (Eq n m) (LT.lt n m)
  
Arguments: {n m : Nat}
Goal: LE.le n m → Or (Eq n m) (LT.lt n m)
-- Nat.lt_or_ge
protected theorem Nat.lt_or_ge (n m : Nat) : Or (LT.lt n m) (GE.ge n m) 
Arguments: (n m : Nat)
Goal: Or (LT.lt n m) (GE.ge n m)
-- Nat.not_succ_le_self
theorem Nat.not_succ_le_self : (n : Nat) → Not (LE.le (succ n) n)
  
Arguments: (n : Nat)
Goal: Not (LE.le n.succ n)
-- Nat.lt_irrefl
protected theorem Nat.lt_irrefl (n : Nat) : Not (LT.lt n n) 
Arguments: (n : Nat)
Goal: Not (LT.lt n n)
-- Nat.lt_of_le_of_lt
protected theorem Nat.lt_of_le_of_lt {n m k : Nat} (h₁ : LE.le n m) (h₂ : LT.lt m k) : LT.lt n k 
Arguments: {n m k : Nat} (h₁ : LE.le n m) (h₂ : LT.lt m k)
Goal: LT.lt n k
-- Nat.le_antisymm
protected theorem Nat.le_antisymm {n m : Nat} (h₁ : LE.le n m) (h₂ : LE.le m n) : Eq n m 
Arguments: {n m : Nat} (h₁ : LE.le n m) (h₂ : LE.le m n)
Goal: Eq n m
-- Nat.lt_of_le_of_ne
protected theorem Nat.lt_of_le_of_ne {n m : Nat} (h₁ : LE.le n m) (h₂ : Not (Eq n m)) : LT.lt n m 
Arguments: {n m : Nat} (h₁ : LE.le n m) (h₂ : Not (Eq n m))
Goal: LT.lt n m
-- Nat.le_of_ble_eq_true
theorem Nat.le_of_ble_eq_true (h : Eq (Nat.ble n m) true) : LE.le n m 
Arguments: {n m : Nat} (h : Eq (n.ble m) true)
Goal: LE.le n m
-- Nat.ble_self_eq_true
theorem Nat.ble_self_eq_true : (n : Nat) → Eq (Nat.ble n n) true
  
Arguments: (n : Nat)
Goal: Eq (n.ble n) true
-- Nat.ble_succ_eq_true
theorem Nat.ble_succ_eq_true : {n m : Nat} → Eq (Nat.ble n m) true → Eq (Nat.ble n (succ m)) true
  
Arguments: {n m : Nat}
Goal: Eq (n.ble m) true → Eq (n.ble m.succ) true
-- Nat.ble_eq_true_of_le
theorem Nat.ble_eq_true_of_le (h : LE.le n m) : Eq (Nat.ble n m) true 
Arguments: {n m : Nat} (h : LE.le n m)
Goal: Eq (n.ble m) true
-- Nat.not_le_of_not_ble_eq_true
theorem Nat.not_le_of_not_ble_eq_true (h : Not (Eq (Nat.ble n m) true)) : Not (LE.le n m) 
Arguments: {n m : Nat} (h : Not (Eq (n.ble m) true))
Goal: Not (LE.le n m)
-- System.Platform.numBits_eq
theorem System.Platform.numBits_eq : Or (Eq numBits 32) (Eq numBits 64) 
Goal: Or (Eq System.Platform.numBits 32) (Eq System.Platform.numBits 64)
-- Fin.isLt
@[pp_using_anonymous_constructor]
structure Fin (n : Nat) where
    mk ::
    val  : Nat
    isLt : LT.lt val n
-- Fin.eq_of_val_eq
theorem Fin.eq_of_val_eq {n} : ∀ {i j : Fin n}, Eq i.val j.val → Eq i j
-- Fin.val_eq_of_eq
theorem Fin.val_eq_of_eq {n} {i j : Fin n} (h : Eq i j) : Eq i.val j.val
-- Fin.ne_of_val_ne
theorem Fin.ne_of_val_ne {n} {i j : Fin n} (h : Not (Eq i.val j.val)) : Not (Eq i j)
-- usize_size_eq
theorem usize_size_eq : Or (Eq USize.size 4294967296) (Eq USize.size 18446744073709551616) 
Goal: Or (Eq USize.size 4294967296) (Eq USize.size 18446744073709551616)
-- Char.valid
structure Char where
    val   : UInt32
    valid : val.isValidChar
Arguments: (self : Char)
Goal: self.val.isValidChar
-- _private.«.lake».packages.lean4.src.lean.Init.Prelude.0.isValidChar_UInt32
private theorem isValidChar_UInt32 {n : Nat} (h : n.isValidChar) : LT.lt n UInt32.size 
Arguments: {n : Nat} (h : n.isValidChar)
Goal: LT.lt n UInt32.size
-- Char.eq_of_val_eq
theorem Char.eq_of_val_eq : ∀ {c d : Char}, Eq c.val d.val → Eq c d
  
Arguments: {c d : Char}
Goal: Eq c.val d.val → Eq c d
-- Char.val_eq_of_eq
theorem Char.val_eq_of_eq : ∀ {c d : Char}, Eq c d → Eq c.val d.val
  
Arguments: {c d : Char}
Goal: Eq c d → Eq c.val d.val
-- Char.ne_of_val_ne
theorem Char.ne_of_val_ne {c d : Char} (h : Not (Eq c.val d.val)) : Not (Eq c d) 
Arguments: {c d : Char} (h : Not (Eq c.val d.val))
Goal: Not (Eq c d)
-- Char.val_ne_of_ne
theorem Char.val_ne_of_ne {c d : Char} (h : Not (Eq c d)) : Not (Eq c.val d.val) 
Arguments: {c d : Char} (h : Not (Eq c d))
Goal: Not (Eq c.val d.val)
-- _private.«.lake».packages.batteries.Batteries.Data.BinomialHeap.Basic.0.Batteries.BinomialHeap.Imp.HeapNode.rankTR_eq
@[csimp] private theorem HeapNode.rankTR_eq : @rankTR = @rank 
Goal: @Batteries.BinomialHeap.Imp.HeapNode.rankTR = @Batteries.BinomialHeap.Imp.HeapNode.rank
-- _private.«.lake».packages.batteries.Batteries.Data.BinomialHeap.Basic.0.Batteries.BinomialHeap.Imp.HeapNode.rankTR_eq.go
@[csimp] private theorem HeapNode.rankTR_eq : @rankTR = @rank 
Arguments: {α : Type u_1} (s : Batteries.BinomialHeap.Imp.HeapNode α) (n : Nat)
Goal: Batteries.BinomialHeap.Imp.HeapNode.rankTR.go s n = s.rank + n
-- Batteries.BinomialHeap.Imp.Heap.realSize_merge
theorem Heap.realSize_merge (le) (s₁ s₂ : Heap α) :
    (s₁.merge le s₂).realSize = s₁.realSize + s₂.realSize 
Arguments: {α : Type u_1} (le : α → α → Bool) (s₁ s₂ : Batteries.BinomialHeap.Imp.Heap α)
Goal: (Batteries.BinomialHeap.Imp.Heap.merge le s₁ s₂).realSize = s₁.realSize + s₂.realSize
-- _private.«.lake».packages.batteries.Batteries.Data.BinomialHeap.Basic.0.Batteries.BinomialHeap.Imp.Heap.realSize_findMin
private theorem Heap.realSize_findMin {s : Heap α}
    (m) (hk : ∀ s, (k s).realSize = m + s.realSize)
    (eq : n = m + s.realSize) (hres : res.HasSize n) :
    (s.findMin le k res).HasSize n 
Arguments: {α : Type u_1} {k : Batteries.BinomialHeap.Imp.Heap α → Batteries.BinomialHeap.Imp.Heap α} {n : Nat} {le : α → α → Bool} {res : Batteries.BinomialHeap.Imp.FindMin α} {s : Batteries.BinomialHeap.Imp.Heap α} (m : Nat) (hk : ∀ (s : Batteries.BinomialHeap.Imp.Heap α), (k s).realSize = m + s.realSize) (eq : n = m + s.realSize) (hres : Batteries.BinomialHeap.Imp.FindMin.HasSize res n)
Goal: Batteries.BinomialHeap.Imp.FindMin.HasSize (Batteries.BinomialHeap.Imp.Heap.findMin le k s res) n
-- Batteries.BinomialHeap.Imp.HeapNode.realSize_toHeap.go
theorem HeapNode.realSize_toHeap (s : HeapNode α) : s.toHeap.realSize = s.realSize 
Arguments: {α : Type u_1} {n : Nat} {res : Batteries.BinomialHeap.Imp.Heap α} (s : Batteries.BinomialHeap.Imp.HeapNode α)
Goal: (Batteries.BinomialHeap.Imp.HeapNode.toHeap.go s n res).realSize = s.realSize + res.realSize
-- Batteries.BinomialHeap.Imp.HeapNode.realSize_toHeap
theorem HeapNode.realSize_toHeap (s : HeapNode α) : s.toHeap.realSize = s.realSize 
Arguments: {α : Type u_1} (s : Batteries.BinomialHeap.Imp.HeapNode α)
Goal: s.toHeap.realSize = s.realSize
-- Batteries.BinomialHeap.Imp.Heap.realSize_deleteMin
theorem Heap.realSize_deleteMin {s : Heap α} (eq : s.deleteMin le = some (a, s')) :
    s.realSize = s'.realSize + 1 
Arguments: {α : Type u_1} {le : α → α → Bool} {a : α} {s' s : Batteries.BinomialHeap.Imp.Heap α} (eq : Batteries.BinomialHeap.Imp.Heap.deleteMin le s = some (a, s'))
Goal: s.realSize = s'.realSize + 1
-- Batteries.BinomialHeap.Imp.Heap.realSize_tail?
theorem Heap.realSize_tail? {s : Heap α} : s.tail? le = some s' →
    s.realSize = s'.realSize + 1 
Arguments: {α : Type u_1} {le : α → α → Bool} {s' s : Batteries.BinomialHeap.Imp.Heap α}
Goal: Batteries.BinomialHeap.Imp.Heap.tail? le s = some s' → s.realSize = s'.realSize + 1
-- Batteries.BinomialHeap.Imp.Heap.realSize_tail
theorem Heap.realSize_tail (le) (s : Heap α) : (s.tail le).realSize = s.realSize - 1 
Arguments: {α : Type u_1} (le : α → α → Bool) (s : Batteries.BinomialHeap.Imp.Heap α)
Goal: (Batteries.BinomialHeap.Imp.Heap.tail le s).realSize = s.realSize - 1
-- Batteries.BinomialHeap.Imp.Heap.WF.nil
theorem Heap.WF.nil : Heap.nil.WF le n 
Goal: ∀ {α : Type u_1} {le : α → α → Bool} {n : Nat},
  Batteries.BinomialHeap.Imp.Heap.WF le n Batteries.BinomialHeap.Imp.Heap.nil
-- Batteries.BinomialHeap.Imp.Heap.WF.singleton
theorem Heap.WF.singleton : (Heap.singleton a).WF le 0 
Goal: ∀ {α : Type u_1} {a : α} {le : α → α → Bool},
  Batteries.BinomialHeap.Imp.Heap.WF le 0 (Batteries.BinomialHeap.Imp.Heap.singleton a)
-- Batteries.BinomialHeap.Imp.Heap.WF.of_rankGT
theorem Heap.WF.of_rankGT (hlt : s.rankGT n) (h : Heap.WF le n' s) : s.WF le (n+1) 
Goal: ∀ {α : Type u_1} {le : α → α → Bool} {n' : Nat} {s : Batteries.BinomialHeap.Imp.Heap α} {n : Nat},
  s.rankGT n → Batteries.BinomialHeap.Imp.Heap.WF le n' s → Batteries.BinomialHeap.Imp.Heap.WF le (n + 1) s
-- Batteries.BinomialHeap.Imp.Heap.WF.of_le
theorem Heap.WF.of_le (hle : n ≤ n') (h : Heap.WF le n' s) : s.WF le n 
Arguments: {n n' : Nat}
Goal: ∀ {α : Type u_1} {le : α → α → Bool} {s : Batteries.BinomialHeap.Imp.Heap α},
  n ≤ n' → Batteries.BinomialHeap.Imp.Heap.WF le n' s → Batteries.BinomialHeap.Imp.Heap.WF le n s
-- Batteries.BinomialHeap.Imp.Heap.rankGT.of_le
theorem Heap.rankGT.of_le (h : Heap.rankGT s n) (h' : n' ≤ n) : s.rankGT n' 
Goal: ∀ {α : Type u_1} {s : Batteries.BinomialHeap.Imp.Heap α} {n n' : Nat}, s.rankGT n → n' ≤ n → s.rankGT n'
-- Batteries.BinomialHeap.Imp.Heap.WF.rankGT
theorem Heap.WF.rankGT (h : Heap.WF lt (n+1) s) : s.rankGT n 
Goal: ∀ {α : Type u_1} {lt : α → α → Bool} {n : Nat} {s : Batteries.BinomialHeap.Imp.Heap α},
  Batteries.BinomialHeap.Imp.Heap.WF lt (n + 1) s → s.rankGT n
-- Batteries.BinomialHeap.Imp.Heap.WF.merge'
theorem Heap.WF.merge' (h₁ : s₁.WF le n) (h₂ : s₂.WF le n) :
    (merge le s₁ s₂).WF le n ∧ ((s₁.rankGT n ↔ s₂.rankGT n) → (merge le s₁ s₂).rankGT n) 
Goal: ∀ {α : Type u_1} {le : α → α → Bool} {s₁ s₂ : Batteries.BinomialHeap.Imp.Heap α} {n : Nat},
  Batteries.BinomialHeap.Imp.Heap.WF le n s₁ →
    Batteries.BinomialHeap.Imp.Heap.WF le n s₂ →
      Batteries.BinomialHeap.Imp.Heap.WF le n (Batteries.BinomialHeap.Imp.Heap.merge le s₁ s₂) ∧
        ((s₁.rankGT n ↔ s₂.rankGT n) → (Batteries.BinomialHeap.Imp.Heap.merge le s₁ s₂).rankGT n)
-- Batteries.BinomialHeap.Imp.Heap.WF.merge
theorem Heap.WF.merge (h₁ : s₁.WF le n) (h₂ : s₂.WF le n) : (merge le s₁ s₂).WF le n 
Goal: ∀ {α : Type u_1} {le : α → α → Bool} {s₁ s₂ : Batteries.BinomialHeap.Imp.Heap α} {n : Nat},
  Batteries.BinomialHeap.Imp.Heap.WF le n s₁ →
    Batteries.BinomialHeap.Imp.Heap.WF le n s₂ →
      Batteries.BinomialHeap.Imp.Heap.WF le n (Batteries.BinomialHeap.Imp.Heap.merge le s₁ s₂)
-- Batteries.BinomialHeap.Imp.HeapNode.WF.rank_eq
theorem HeapNode.WF.rank_eq : ∀ {n} {s : HeapNode α}, s.WF le a n → s.rank = n
  
Arguments: {α : Type u_1} {le : α → α → Bool} {a : α} {n : Nat} {s : Batteries.BinomialHeap.Imp.HeapNode α}
Goal: Batteries.BinomialHeap.Imp.HeapNode.WF le a s n → s.rank = n
-- Batteries.BinomialHeap.Imp.HeapNode.WF.toHeap
theorem HeapNode.WF.toHeap {s : HeapNode α} (h : s.WF le a n) : s.toHeap.WF le 0 
Arguments: {α : Type u_1} {le : α → α → Bool} {a : α} {n : Nat} {s : Batteries.BinomialHeap.Imp.HeapNode α} (h : Batteries.BinomialHeap.Imp.HeapNode.WF le a s n)
Goal: Batteries.BinomialHeap.Imp.Heap.WF le 0 s.toHeap
-- Batteries.BinomialHeap.Imp.HeapNode.WF.toHeap.go
theorem HeapNode.WF.toHeap {s : HeapNode α} (h : s.WF le a n) : s.toHeap.WF le 0 
Arguments: {α : Type u_1} {le : α → α → Bool} {a : α} {res : Batteries.BinomialHeap.Imp.Heap α} {n : Nat} {s : Batteries.BinomialHeap.Imp.HeapNode α}
Goal: Batteries.BinomialHeap.Imp.HeapNode.WF le a s n →
  Batteries.BinomialHeap.Imp.Heap.WF le s.rank res →
    Batteries.BinomialHeap.Imp.Heap.WF le 0 (Batteries.BinomialHeap.Imp.HeapNode.toHeap.go s s.rank res)
-- Batteries.BinomialHeap.Imp.FindMin.WF.next
structure FindMin.WF (le : α → α → Bool) (res : FindMin α) where
    rank : Nat
    before : ∀ {s}, s.WF le rank → (res.before s).WF le 0
    node : res.node.WF le res.val rank
    next : res.next.WF le (rank + 1)
Arguments: {α : Type u_1} {le : α → α → Bool} {res : Batteries.BinomialHeap.Imp.FindMin α} (self : Batteries.BinomialHeap.Imp.FindMin.WF le res)
Goal: Batteries.BinomialHeap.Imp.Heap.WF le (self.rank + 1) res.next
-- Batteries.BinomialHeap.Imp.FindMin.WF.node
structure FindMin.WF (le : α → α → Bool) (res : FindMin α) where
    rank : Nat
    before : ∀ {s}, s.WF le rank → (res.before s).WF le 0
    node : res.node.WF le res.val rank
    next : res.next.WF le (rank + 1)
Arguments: {α : Type u_1} {le : α → α → Bool} {res : Batteries.BinomialHeap.Imp.FindMin α} (self : Batteries.BinomialHeap.Imp.FindMin.WF le res)
Goal: Batteries.BinomialHeap.Imp.HeapNode.WF le res.val res.node self.rank
-- Batteries.BinomialHeap.Imp.FindMin.WF.before
structure FindMin.WF (le : α → α → Bool) (res : FindMin α) where
    rank : Nat
    before : ∀ {s}, s.WF le rank → (res.before s).WF le 0
    node : res.node.WF le res.val rank
    next : res.next.WF le (rank + 1)
Arguments: {α : Type u_1} {le : α → α → Bool} {res : Batteries.BinomialHeap.Imp.FindMin α} (self : Batteries.BinomialHeap.Imp.FindMin.WF le res) {s : Batteries.BinomialHeap.Imp.Heap α}
Goal: Batteries.BinomialHeap.Imp.Heap.WF le self.rank s → Batteries.BinomialHeap.Imp.Heap.WF le 0 (res.before s)
-- Batteries.BinomialHeap.Imp.Heap.WF.deleteMin
theorem Heap.WF.deleteMin {s : Heap α}
    (h : s.WF le n) (eq : s.deleteMin le = some (a, s')) : s'.WF le 0 
Arguments: {α : Type u_1} {le : α → α → Bool} {n : Nat} {a : α} {s' s : Batteries.BinomialHeap.Imp.Heap α} (h : Batteries.BinomialHeap.Imp.Heap.WF le n s) (eq : Batteries.BinomialHeap.Imp.Heap.deleteMin le s = some (a, s'))
Goal: Batteries.BinomialHeap.Imp.Heap.WF le 0 s'
-- Batteries.BinomialHeap.Imp.Heap.WF.tail?
theorem Heap.WF.tail? (hwf : (s : Heap α).WF le n) : s.tail? le = some tl → tl.WF le 0 
Arguments: {α : Type u_1} {s : Batteries.BinomialHeap.Imp.Heap α} {le : α → α → Bool} {n : Nat} {tl : Batteries.BinomialHeap.Imp.Heap α} (hwf : Batteries.BinomialHeap.Imp.Heap.WF le n s)
Goal: Batteries.BinomialHeap.Imp.Heap.tail? le s = some tl → Batteries.BinomialHeap.Imp.Heap.WF le 0 tl
-- Batteries.BinomialHeap.Imp.Heap.WF.tail
theorem Heap.WF.tail (hwf : (s : Heap α).WF le n) : (s.tail le).WF le 0 
Arguments: {α : Type u_1} {s : Batteries.BinomialHeap.Imp.Heap α} {le : α → α → Bool} {n : Nat} (hwf : Batteries.BinomialHeap.Imp.Heap.WF le n s)
Goal: Batteries.BinomialHeap.Imp.Heap.WF le 0 (Batteries.BinomialHeap.Imp.Heap.tail le s)
-- Int.default_eq_zero
@[simp] theorem default_eq_zero : default = (0 : Int) 
Goal: default = 0
-- Int.zero_ne_one
protected theorem zero_ne_one : (0 : Int) ≠ 1 
Goal: 0 ≠ 1
-- Int.ofNat_eq_coe
@[simp] theorem ofNat_eq_coe : Int.ofNat n = Nat.cast n 
Arguments: {n : Nat}
Goal: Int.ofNat n = ↑n
-- Int.ofNat_zero
@[simp] theorem ofNat_zero : ((0 : Nat) : Int) = 0 
Goal: ↑0 = 0
-- Int.ofNat_one
@[simp] theorem ofNat_one  : ((1 : Nat) : Int) = 1 
Goal: ↑1 = 1
-- Int.ofNat_two
theorem ofNat_two : ((2 : Nat) : Int) = 2 
Goal: ↑2 = 2
-- Int.shiftRight_eq
theorem shiftRight_eq (n : Int) (s : Nat) : n >>> s = Int.shiftRight n s 
Arguments: (n : Int) (s : Nat)
Goal: n >>> s = n.shiftRight s
-- Int.natCast_shiftRight
@[simp]
theorem natCast_shiftRight (n s : Nat) : (n : Int) >>> s = n >>> s 
Arguments: (n s : Nat)
Goal: ↑n >>> s = ↑(n >>> s)
-- Int.negSucc_shiftRight
@[simp]
theorem negSucc_shiftRight (m n : Nat) :
    -[m+1] >>> n = -[m >>>n +1] 
Arguments: (m n : Nat)
Goal: Int.negSucc m >>> n = Int.negSucc (m >>> n)
-- Int.shiftRight_add
theorem shiftRight_add (i : Int) (m n : Nat) :
    i >>> (m + n) = i >>> m >>> n 
Arguments: (i : Int) (m n : Nat)
Goal: i >>> (m + n) = i >>> m >>> n
-- Int.shiftRight_eq_div_pow
theorem shiftRight_eq_div_pow (m : Int) (n : Nat) :
    m >>> n = m / ((2 ^ n) : Nat) 
Arguments: (m : Int) (n : Nat)
Goal: m >>> n = m / ↑(2 ^ n)
-- Int.zero_shiftRight
@[simp]
theorem zero_shiftRight (n : Nat) : (0 : Int) >>> n = 0 
Arguments: (n : Nat)
Goal: 0 >>> n = 0
-- Int.ofNat_ediv
@[simp, norm_cast] theorem ofNat_ediv (m n : Nat) : (↑(m / n) : Int) = ↑m / ↑n 
Arguments: (m n : Nat)
Goal: ↑(m / n) = ↑m / ↑n
-- Int.ofNat_div
theorem ofNat_div (m n : Nat) : ↑(m / n) = div ↑m ↑n 
Arguments: (m n : Nat)
Goal: ↑(m / n) = (↑m).div ↑n
-- Int.ofNat_fdiv
theorem ofNat_fdiv : ∀ m n : Nat, ↑(m / n) = fdiv ↑m ↑n
  
Arguments: (m n : Nat)
Goal: ↑(m / n) = (↑m).fdiv ↑n
-- Int.pow_zero
protected theorem pow_zero (b : Int) : b^0 = 1 
Arguments: (b : Int)
Goal: b ^ 0 = 1
-- Int.pow_succ
protected theorem pow_succ (b : Int) (e : Nat) : b ^ (e+1) = (b ^ e) * b 
Arguments: (b : Int) (e : Nat)
Goal: b ^ (e + 1) = b ^ e * b
-- Int.pow_succ'
protected theorem pow_succ' (b : Int) (e : Nat) : b ^ (e+1) = b * (b ^ e) 
Arguments: (b : Int) (e : Nat)
Goal: b ^ (e + 1) = b * b ^ e
-- Int.pow_le_pow_of_le_left
theorem pow_le_pow_of_le_left {n m : Nat} (h : n ≤ m) : ∀ (i : Nat), n^i ≤ m^i
  
Arguments: {n m : Nat} (h : n ≤ m) (i : Nat)
Goal: n ^ i ≤ m ^ i
-- Int.pow_le_pow_of_le_right
theorem pow_le_pow_of_le_right {n : Nat} (hx : n > 0) {i : Nat} : ∀ {j}, i ≤ j → n^i ≤ n^j
  
Arguments: {n : Nat} (hx : n > 0) {i j : Nat}
Goal: i ≤ j → n ^ i ≤ n ^ j
-- Int.pos_pow_of_pos
theorem pos_pow_of_pos {n : Nat} (m : Nat) (h : 0 < n) : 0 < n^m 
Arguments: {n : Nat} (m : Nat) (h : 0 < n)
Goal: 0 < n ^ m
-- Int.natCast_pow
theorem natCast_pow (b n : Nat) : ((b^n : Nat) : Int) = (b : Int) ^ n 
Arguments: (b n : Nat)
Goal: ↑(b ^ n) = ↑b ^ n
-- Int.gcd_dvd_left
theorem gcd_dvd_left {a b : Int} : (gcd a b : Int) ∣ a 
Arguments: {a b : Int}
Goal: ↑(a.gcd b) ∣ a
-- Int.gcd_dvd_right
theorem gcd_dvd_right {a b : Int} : (gcd a b : Int) ∣ b 
Arguments: {a b : Int}
Goal: ↑(a.gcd b) ∣ b
-- Int.one_gcd
@[simp] theorem one_gcd {a : Int} : gcd 1 a = 1 
Arguments: {a : Int}
Goal: Int.gcd 1 a = 1
-- Int.gcd_one
@[simp] theorem gcd_one {a : Int} : gcd a 1 = 1 
Arguments: {a : Int}
Goal: a.gcd 1 = 1
-- Int.neg_gcd
@[simp] theorem neg_gcd {a b : Int} : gcd (-a) b = gcd a b 
Arguments: {a b : Int}
Goal: (-a).gcd b = a.gcd b
-- Int.gcd_neg
@[simp] theorem gcd_neg {a b : Int} : gcd a (-b) = gcd a b 
Arguments: {a b : Int}
Goal: a.gcd (-b) = a.gcd b
-- Int.lcm_ne_zero
theorem lcm_ne_zero (hm : m ≠ 0) (hn : n ≠ 0) : lcm m n ≠ 0 
Arguments: {m n : Int} (hm : m ≠ 0) (hn : n ≠ 0)
Goal: m.lcm n ≠ 0
-- Int.dvd_lcm_left
theorem dvd_lcm_left {a b : Int} : a ∣ lcm a b 
Arguments: {a b : Int}
Goal: a ∣ ↑(a.lcm b)
-- Int.dvd_lcm_right
theorem dvd_lcm_right {a b : Int} : b ∣ lcm a b 
Arguments: {a b : Int}
Goal: b ∣ ↑(a.lcm b)
-- Int.lcm_self
@[simp] theorem lcm_self {a : Int} : lcm a a = a.natAbs 
Arguments: {a : Int}
Goal: a.lcm a = a.natAbs
-- String.lt_trans
theorem lt_trans {s₁ s₂ s₃ : String} : s₁ < s₂ → s₂ < s₃ → s₁ < s₃ 
Arguments: {s₁ s₂ s₃ : String}
Goal: s₁ < s₂ → s₂ < s₃ → s₁ < s₃
-- String.lt_antisymm
theorem lt_antisymm {s₁ s₂ : String} (h₁ : ¬s₁ < s₂) (h₂ : ¬s₂ < s₁) : s₁ = s₂ 
Arguments: {s₁ s₂ : String} (h₁ : ¬s₁ < s₂) (h₂ : ¬s₂ < s₁)
Goal: s₁ = s₂
-- String.mk_length
@[simp] theorem mk_length (s : List Char) : (String.mk s).length = s.length 
Arguments: (s : List Char)
Goal: { data := s }.length = s.length
-- _private.«.lake».packages.batteries.Batteries.Data.String.Lemmas.0.String.add_csize_pos
private theorem add_csize_pos : 0 < i + Char.utf8Size c 
Arguments: {i : Nat} {c : Char}
Goal: 0 < i + c.utf8Size
-- _private.«.lake».packages.batteries.Batteries.Data.String.Lemmas.0.String.ne_add_csize_add_self
private theorem ne_add_csize_add_self : i ≠ n + Char.utf8Size c + i 
Arguments: {i n : Nat} {c : Char}
Goal: i ≠ n + c.utf8Size + i
-- _private.«.lake».packages.batteries.Batteries.Data.String.Lemmas.0.String.ne_self_add_add_csize
private theorem ne_self_add_add_csize : i ≠ i + (n + Char.utf8Size c) 
Arguments: {i n : Nat} {c : Char}
Goal: i ≠ i + (n + c.utf8Size)
-- String.utf8ByteSize.go_eq
@[simp] theorem utf8ByteSize.go_eq : utf8ByteSize.go = utf8Len 
Goal: String.utf8ByteSize.go = String.utf8Len
-- String.utf8ByteSize_mk
@[simp] theorem utf8ByteSize_mk (cs) : utf8ByteSize ⟨cs⟩ = utf8Len cs 
Arguments: (cs : List Char)
Goal: { data := cs }.utf8ByteSize = String.utf8Len cs
-- String.utf8Len_nil
@[simp] theorem utf8Len_nil : utf8Len [] = 0 
Goal: String.utf8Len [] = 0
-- String.utf8Len_cons
@[simp] theorem utf8Len_cons (c cs) : utf8Len (c :: cs) = utf8Len cs + c.utf8Size 
Arguments: (c : Char) (cs : List Char)
Goal: String.utf8Len (c :: cs) = String.utf8Len cs + c.utf8Size
-- String.utf8Len_append
@[simp] theorem utf8Len_append (cs₁ cs₂) : utf8Len (cs₁ ++ cs₂) = utf8Len cs₁ + utf8Len cs₂ 
Arguments: (cs₁ cs₂ : List Char)
Goal: String.utf8Len (cs₁ ++ cs₂) = String.utf8Len cs₁ + String.utf8Len cs₂
-- String.utf8Len_reverseAux
@[simp] theorem utf8Len_reverseAux (cs₁ cs₂) :
    utf8Len (cs₁.reverseAux cs₂) = utf8Len cs₁ + utf8Len cs₂ 
Arguments: (cs₁ cs₂ : List Char)
Goal: String.utf8Len (cs₁.reverseAux cs₂) = String.utf8Len cs₁ + String.utf8Len cs₂
-- String.utf8Len_reverse
@[simp] theorem utf8Len_reverse (cs) : utf8Len cs.reverse = utf8Len cs 
Arguments: (cs : List Char)
Goal: String.utf8Len cs.reverse = String.utf8Len cs
-- String.utf8Len_eq_zero
@[simp] theorem utf8Len_eq_zero : utf8Len l = 0 ↔ l = [] 
Arguments: {l : List Char}
Goal: String.utf8Len l = 0 ↔ l = []
-- String.utf8Len_le_of_sublist
theorem utf8Len_le_of_sublist : ∀ {cs₁ cs₂}, cs₁ <+ cs₂ → utf8Len cs₁ ≤ utf8Len cs₂
  
Arguments: {cs₁ cs₂ : List Char}
Goal: cs₁.Sublist cs₂ → String.utf8Len cs₁ ≤ String.utf8Len cs₂
-- String.utf8Len_le_of_infix
theorem utf8Len_le_of_infix (h : cs₁ <:+: cs₂) : utf8Len cs₁ ≤ utf8Len cs₂ 
Arguments: {cs₁ cs₂ : List Char} (h : cs₁ <:+: cs₂)
Goal: String.utf8Len cs₁ ≤ String.utf8Len cs₂
-- String.utf8Len_le_of_suffix
theorem utf8Len_le_of_suffix (h : cs₁ <:+ cs₂) : utf8Len cs₁ ≤ utf8Len cs₂ 
Arguments: {cs₁ cs₂ : List Char} (h : cs₁ <:+ cs₂)
Goal: String.utf8Len cs₁ ≤ String.utf8Len cs₂
-- String.utf8Len_le_of_prefix
theorem utf8Len_le_of_prefix (h : cs₁ <+: cs₂) : utf8Len cs₁ ≤ utf8Len cs₂ 
Arguments: {cs₁ cs₂ : List Char} (h : cs₁ <+: cs₂)
Goal: String.utf8Len cs₁ ≤ String.utf8Len cs₂
-- String.endPos_eq
@[simp] theorem endPos_eq (cs : List Char) : endPos ⟨cs⟩ = ⟨utf8Len cs⟩ 
Arguments: (cs : List Char)
Goal: { data := cs }.endPos = { byteIdx := String.utf8Len cs }
-- String.Pos.lt_addChar
theorem lt_addChar (p : Pos) (c : Char) : p < p + c 
Arguments: (p : String.Pos) (c : Char)
Goal: p < p + c
-- _private.«.lake».packages.batteries.Batteries.Data.String.Lemmas.0.String.Pos.zero_ne_addChar
private theorem zero_ne_addChar {i : Pos} {c : Char} : 0 ≠ i + c 
Arguments: {i : String.Pos} {c : Char}
Goal: 0 ≠ i + c
-- String.Pos.valid_zero
@[simp] theorem valid_zero : Valid s 0 
Arguments: {s : String}
Goal: String.Pos.Valid s 0
-- String.Pos.valid_endPos
@[simp] theorem valid_endPos : Valid s (endPos s) 
Arguments: {s : String}
Goal: String.Pos.Valid s s.endPos
-- String.Pos.Valid.mk
theorem Valid.mk (cs cs' : List Char) : Valid ⟨cs ++ cs'⟩ ⟨utf8Len cs⟩ 
Arguments: (cs cs' : List Char)
Goal: String.Pos.Valid { data := cs ++ cs' } { byteIdx := String.utf8Len cs }
-- String.Pos.Valid.le_endPos
theorem Valid.le_endPos : ∀ {s p}, Valid s p → p ≤ endPos s
  
Arguments: {s : String} {p : String.Pos}
Goal: String.Pos.Valid s p → p ≤ s.endPos
-- String.endPos_eq_zero
theorem endPos_eq_zero : ∀ (s : String), endPos s = 0 ↔ s = ""
  
Arguments: (s : String)
Goal: s.endPos = 0 ↔ s = ""
-- String.isEmpty_iff
theorem isEmpty_iff (s : String) : isEmpty s ↔ s = "" 
Arguments: (s : String)
Goal: s.isEmpty = true ↔ s = ""
-- String.utf8GetAux_add_right_cancel
theorem utf8GetAux_add_right_cancel (s : List Char) (i p n : Nat) :
    utf8GetAux s ⟨i + n⟩ ⟨p + n⟩ = utf8GetAux s ⟨i⟩ ⟨p⟩ 
Arguments: (s : List Char) (i p n : Nat)
Goal: String.utf8GetAux s { byteIdx := i + n } { byteIdx := p + n } = String.utf8GetAux s { byteIdx := i } { byteIdx := p }
-- String.utf8GetAux_addChar_right_cancel
theorem utf8GetAux_addChar_right_cancel (s : List Char) (i p : Pos) (c : Char) :
    utf8GetAux s (i + c) (p + c) = utf8GetAux s i p 
Arguments: (s : List Char) (i p : String.Pos) (c : Char)
Goal: String.utf8GetAux s (i + c) (p + c) = String.utf8GetAux s i p
-- String.utf8GetAux_of_valid
theorem utf8GetAux_of_valid (cs cs' : List Char) {i p : Nat} (hp : i + utf8Len cs = p) :
    utf8GetAux (cs ++ cs') ⟨i⟩ ⟨p⟩ = cs'.headD default 
Arguments: (cs cs' : List Char) {i p : Nat} (hp : i + String.utf8Len cs = p)
Goal: String.utf8GetAux (cs ++ cs') { byteIdx := i } { byteIdx := p } = cs'.headD default
-- String.get_of_valid
theorem get_of_valid (cs cs' : List Char) : get ⟨cs ++ cs'⟩ ⟨utf8Len cs⟩ = cs'.headD default 
Arguments: (cs cs' : List Char)
Goal: { data := cs ++ cs' }.get { byteIdx := String.utf8Len cs } = cs'.headD default
-- String.get_cons_addChar
theorem get_cons_addChar (c : Char) (cs : List Char) (i : Pos) :
    get ⟨c :: cs⟩ (i + c) = get ⟨cs⟩ i 
Arguments: (c : Char) (cs : List Char) (i : String.Pos)
Goal: { data := c :: cs }.get (i + c) = { data := cs }.get i