ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- BitVec.allOnes_sub_eq_not
theorem allOnes_sub_eq_not (x : BitVec w) : allOnes w - x = ~~~x 
Arguments: {w : Nat} (x : BitVec w)
Goal: BitVec.allOnes w - x = ~~~x
-- BitVec.bit_not_testBit
theorem bit_not_testBit (x : BitVec w) (i : Fin w) :
  getLsb (((iunfoldr (fun (i : Fin w) c => (c, !(x.getLsb i)))) ()).snd) i.val = !(getLsb x i.val) 
Arguments: {w : Nat} (x : BitVec w) (i : Fin w)
Goal: (BitVec.iunfoldr (fun i c => (c, !x.getLsb ↑i)) ()).snd.getLsb ↑i = !x.getLsb ↑i
-- BitVec.bit_not_add_self
theorem bit_not_add_self (x : BitVec w) :
  ((iunfoldr (fun (i : Fin w) c => (c, !(x.getLsb i)))) ()).snd + x  = -1 
Arguments: {w : Nat} (x : BitVec w)
Goal: (BitVec.iunfoldr (fun i c => (c, !x.getLsb ↑i)) ()).snd + x = -1
-- BitVec.bit_not_eq_not
theorem bit_not_eq_not (x : BitVec w) :
  ((iunfoldr (fun i c => (c, !(x.getLsb i)))) ()).snd = ~~~ x 
Arguments: {w : Nat} (x : BitVec w)
Goal: (BitVec.iunfoldr (fun i c => (c, !x.getLsb ↑i)) ()).snd = ~~~x
-- BitVec.bit_neg_eq_neg
theorem bit_neg_eq_neg (x : BitVec w) : -x = (adc (((iunfoldr (fun (i : Fin w) c => (c, !(x.getLsb i)))) ()).snd) (BitVec.ofNat w 1) false).snd
Arguments: {w : Nat} (x : BitVec w)
Goal: -x = ((BitVec.iunfoldr (fun i c => (c, !x.getLsb ↑i)) ()).snd.adc (1#w) false).snd
-- BitVec.ult_eq_not_carry
theorem ult_eq_not_carry (x y : BitVec w) : x.ult y = !carry w x (~~~y) true 
Arguments: {w : Nat} (x y : BitVec w)
Goal: x.ult y = !BitVec.carry w x (~~~y) true
-- BitVec.ule_eq_not_ult
theorem ule_eq_not_ult (x y : BitVec w) : x.ule y = !y.ult x 
Arguments: {w : Nat} (x y : BitVec w)
Goal: x.ule y = !y.ult x
-- BitVec.ule_eq_carry
theorem ule_eq_carry (x y : BitVec w) : x.ule y = carry w y (~~~x) true 
Arguments: {w : Nat} (x y : BitVec w)
Goal: x.ule y = BitVec.carry w y (~~~x) true
-- BitVec.slt_eq_ult_of_msb_eq
theorem slt_eq_ult_of_msb_eq {x y : BitVec w} (h : x.msb = y.msb) :
    x.slt y = x.ult y 
Arguments: {w : Nat} {x y : BitVec w} (h : x.msb = y.msb)
Goal: x.slt y = x.ult y
-- BitVec.ult_eq_msb_of_msb_neq
theorem ult_eq_msb_of_msb_neq {x y : BitVec w} (h : x.msb ≠ y.msb) :
    x.ult y = y.msb 
Arguments: {w : Nat} {x y : BitVec w} (h : x.msb ≠ y.msb)
Goal: x.ult y = y.msb
-- BitVec.slt_eq_not_ult_of_msb_neq
theorem slt_eq_not_ult_of_msb_neq {x y : BitVec w} (h : x.msb ≠ y.msb) :
    x.slt y = !x.ult y 
Arguments: {w : Nat} {x y : BitVec w} (h : x.msb ≠ y.msb)
Goal: x.slt y = !x.ult y
-- BitVec.slt_eq_ult
theorem slt_eq_ult (x y : BitVec w) :
    x.slt y = (x.msb != y.msb).xor (x.ult y) 
Arguments: {w : Nat} (x y : BitVec w)
Goal: x.slt y = (x.msb != y.msb).xor (x.ult y)
-- BitVec.slt_eq_not_carry
theorem slt_eq_not_carry (x y : BitVec w) :
    x.slt y = (x.msb == y.msb).xor (carry w x (~~~y) true) 
Arguments: {w : Nat} (x y : BitVec w)
Goal: x.slt y = (x.msb == y.msb).xor (BitVec.carry w x (~~~y) true)
-- BitVec.sle_eq_not_slt
theorem sle_eq_not_slt (x y : BitVec w) : x.sle y = !y.slt x 
Arguments: {w : Nat} (x y : BitVec w)
Goal: x.sle y = !y.slt x
-- BitVec.sle_eq_carry
theorem sle_eq_carry (x y : BitVec w) :
    x.sle y = !((x.msb == y.msb).xor (carry w y (~~~x) true)) 
Arguments: {w : Nat} (x y : BitVec w)
Goal: x.sle y = !(x.msb == y.msb).xor (BitVec.carry w y (~~~x) true)
-- Lean.Data.AC.Context.assoc
structure Context (α : Sort u) where
  op : α → α → α
  assoc : Associative op
  comm : Option $ PLift $ Commutative op
  idem : Option $ PLift $ IdempotentOp op
  vars : List (Variable op)
  arbitrary : α
Arguments: {α : Sort u} (self : Lean.Data.AC.Context α)
Goal: Std.Associative self.op
-- Lean.Data.AC.Context.mergeIdem_nonEmpty
theorem Context.mergeIdem_nonEmpty (e : List Nat) (h : e ≠ []) : mergeIdem e ≠ [] 
Arguments: (e : List Nat) (h : e ≠ [])
Goal: Lean.Data.AC.mergeIdem e ≠ []
-- Lean.Data.AC.Context.mergeIdem_head
theorem Context.mergeIdem_head : mergeIdem (x :: x :: xs) = mergeIdem (x :: xs) 
Arguments: {x : Nat} {xs : List Nat}
Goal: Lean.Data.AC.mergeIdem (x :: x :: xs) = Lean.Data.AC.mergeIdem (x :: xs)
-- Lean.Data.AC.Context.mergeIdem_head2
theorem Context.mergeIdem_head2 (h : x ≠ y) : mergeIdem (x :: y :: ys) = x :: mergeIdem (y :: ys) 
Arguments: {x y : Nat} {ys : List Nat} (h : x ≠ y)
Goal: Lean.Data.AC.mergeIdem (x :: y :: ys) = x :: Lean.Data.AC.mergeIdem (y :: ys)
-- Lean.Data.AC.Context.evalList_mergeIdem
theorem Context.evalList_mergeIdem (ctx : Context α) (h : ContextInformation.isIdem ctx) (e : List Nat) : evalList α ctx (mergeIdem e) = evalList α ctx e 
Arguments: {α : Sort u_1} (ctx : Lean.Data.AC.Context α) (h : Lean.Data.AC.ContextInformation.isIdem ctx = true) (e : List Nat)
Goal: Lean.Data.AC.evalList α ctx (Lean.Data.AC.mergeIdem e) = Lean.Data.AC.evalList α ctx e
-- Lean.Data.AC.insert_nonEmpty
theorem insert_nonEmpty : insert x xs ≠ [] 
Arguments: {x : Nat} {xs : List Nat}
Goal: Lean.Data.AC.insert x xs ≠ []
-- Lean.Data.AC.Context.sort_loop_nonEmpty
theorem Context.sort_loop_nonEmpty (xs : List Nat) (h : xs ≠ []) : sort.loop xs ys ≠ [] 
Arguments: {ys : List Nat} (xs : List Nat) (h : xs ≠ [])
Goal: Lean.Data.AC.sort.loop xs ys ≠ []
-- Lean.Data.AC.Context.evalList_insert
theorem Context.evalList_insert
  (ctx : Context α)
  (h : Commutative ctx.op)
  (x : Nat)
  (xs : List Nat)
  : evalList α ctx (insert x xs) = evalList α ctx (x::xs) 
Arguments: {α : Sort u_1} (ctx : Lean.Data.AC.Context α) (h : Std.Commutative ctx.op) (x : Nat) (xs : List Nat)
Goal: Lean.Data.AC.evalList α ctx (Lean.Data.AC.insert x xs) = Lean.Data.AC.evalList α ctx (x :: xs)
-- Lean.Data.AC.Context.evalList_sort_congr
theorem Context.evalList_sort_congr
  (ctx : Context α)
  (h : Commutative ctx.op)
  (h₂ : evalList α ctx a = evalList α ctx b)
  (h₃ : a ≠ [])
  (h₄ : b ≠ [])
  : evalList α ctx (sort.loop a c) = evalList α ctx (sort.loop b c) 
Arguments: {α : Sort u_1} {a b c : List Nat} (ctx : Lean.Data.AC.Context α) (h : Std.Commutative ctx.op) (h₂ : Lean.Data.AC.evalList α ctx a = Lean.Data.AC.evalList α ctx b) (h₃ : a ≠ []) (h₄ : b ≠ [])
Goal: Lean.Data.AC.evalList α ctx (Lean.Data.AC.sort.loop a c) = Lean.Data.AC.evalList α ctx (Lean.Data.AC.sort.loop b c)
-- Lean.Data.AC.Context.evalList_sort_loop_swap
theorem Context.evalList_sort_loop_swap
  (ctx : Context α)
  (h : Commutative ctx.op)
  (xs ys : List Nat)
  : evalList α ctx (sort.loop xs (y::ys)) = evalList α ctx (sort.loop (y::xs) ys) 
Arguments: {α : Sort u_1} {y : Nat} (ctx : Lean.Data.AC.Context α) (h : Std.Commutative ctx.op) (xs ys : List Nat)
Goal: Lean.Data.AC.evalList α ctx (Lean.Data.AC.sort.loop xs (y :: ys)) =
  Lean.Data.AC.evalList α ctx (Lean.Data.AC.sort.loop (y :: xs) ys)
-- Lean.Data.AC.Context.evalList_sort_cons
theorem Context.evalList_sort_cons
  (ctx : Context α)
  (h : Commutative ctx.op)
  (x : Nat)
  (xs : List Nat)
  : evalList α ctx (sort (x :: xs)) = evalList α ctx (x :: sort xs) 
Arguments: {α : Sort u_1} (ctx : Lean.Data.AC.Context α) (h : Std.Commutative ctx.op) (x : Nat) (xs : List Nat)
Goal: Lean.Data.AC.evalList α ctx (Lean.Data.AC.sort (x :: xs)) = Lean.Data.AC.evalList α ctx (x :: Lean.Data.AC.sort xs)
-- Lean.Data.AC.Context.evalList_sort
theorem Context.evalList_sort (ctx : Context α) (h : ContextInformation.isComm ctx) (e : List Nat) : evalList α ctx (sort e) = evalList α ctx e 
Arguments: {α : Sort u_1} (ctx : Lean.Data.AC.Context α) (h : Lean.Data.AC.ContextInformation.isComm ctx = true) (e : List Nat)
Goal: Lean.Data.AC.evalList α ctx (Lean.Data.AC.sort e) = Lean.Data.AC.evalList α ctx e
-- Lean.Data.AC.Context.toList_nonEmpty
theorem Context.toList_nonEmpty (e : Expr) : e.toList ≠ [] 
Arguments: (e : Lean.Data.AC.Expr)
Goal: e.toList ≠ []
-- Lean.Data.AC.Context.unwrap_isNeutral
theorem Context.unwrap_isNeutral
  {ctx : Context α}
  {x : Nat}
  : ContextInformation.isNeutral ctx x = true → LawfulIdentity (EvalInformation.evalOp ctx) (EvalInformation.evalVar (β := α) ctx x) 
Arguments: {α : Sort u_1} {ctx : Lean.Data.AC.Context α} {x : Nat}
Goal: Lean.Data.AC.ContextInformation.isNeutral ctx x = true →
  Std.LawfulIdentity (Lean.Data.AC.EvalInformation.evalOp ctx) (Lean.Data.AC.EvalInformation.evalVar ctx x)
-- Lean.Data.AC.Context.evalList_removeNeutrals
theorem Context.evalList_removeNeutrals (ctx : Context α) (e : List Nat) : evalList α ctx (removeNeutrals ctx e) = evalList α ctx e 
Arguments: {α : Sort u_1} (ctx : Lean.Data.AC.Context α) (e : List Nat)
Goal: Lean.Data.AC.evalList α ctx (Lean.Data.AC.removeNeutrals ctx e) = Lean.Data.AC.evalList α ctx e
-- Lean.Data.AC.Context.evalList_append
theorem Context.evalList_append
  (ctx : Context α)
  (l r : List Nat)
  (h₁ : l ≠ [])
  (h₂ : r ≠ [])
  : evalList α ctx (l.append r) = ctx.op (evalList α ctx l) (evalList α ctx r) 
Arguments: {α : Sort u_1} (ctx : Lean.Data.AC.Context α) (l r : List Nat) (h₁ : l ≠ []) (h₂ : r ≠ [])
Goal: Lean.Data.AC.evalList α ctx (l.append r) = ctx.op (Lean.Data.AC.evalList α ctx l) (Lean.Data.AC.evalList α ctx r)
-- Lean.Data.AC.Context.eval_toList
theorem Context.eval_toList (ctx : Context α) (e : Expr) : evalList α ctx e.toList = eval α ctx e 
Arguments: {α : Sort u_1} (ctx : Lean.Data.AC.Context α) (e : Lean.Data.AC.Expr)
Goal: Lean.Data.AC.evalList α ctx e.toList = Lean.Data.AC.eval α ctx e
-- Lean.Data.AC.Context.eval_norm
theorem Context.eval_norm (ctx : Context α) (e : Expr) : evalList α ctx (norm ctx e) = eval α ctx e 
Arguments: {α : Sort u_1} (ctx : Lean.Data.AC.Context α) (e : Lean.Data.AC.Expr)
Goal: Lean.Data.AC.evalList α ctx (Lean.Data.AC.norm ctx e) = Lean.Data.AC.eval α ctx e
-- Lean.Data.AC.Context.eq_of_norm
theorem Context.eq_of_norm (ctx : Context α) (a b : Expr) (h : norm ctx a == norm ctx b) : eval α ctx a = eval α ctx b 
Arguments: {α : Sort u_1} (ctx : Lean.Data.AC.Context α) (a b : Lean.Data.AC.Expr) (h : (Lean.Data.AC.norm ctx a == Lean.Data.AC.norm ctx b) = true)
Goal: Lean.Data.AC.eval α ctx a = Lean.Data.AC.eval α ctx b
-- Lake.NPackage.name_eq
structure NPackage (name : Name) extends Package where
  name_eq : toPackage.name = name
Arguments: {name : Lake.Name} (self : Lake.NPackage name)
Goal: self.name = name
-- Char.utf8Size_pos
theorem _root_.Char.utf8Size_pos (c : Char) : 0 < c.utf8Size 
Arguments: (c : Char)
Goal: 0 < c.utf8Size
-- Char.utf8Size_le_four
theorem _root_.Char.utf8Size_le_four (c : Char) : c.utf8Size ≤ 4 
Arguments: (c : Char)
Goal: c.utf8Size ≤ 4
-- String.pos_lt_eq
@[simp] theorem pos_lt_eq (p₁ p₂ : Pos) : (p₁ < p₂) = (p₁.1 < p₂.1) 
Arguments: (p₁ p₂ : String.Pos)
Goal: (p₁ < p₂) = (p₁.byteIdx < p₂.byteIdx)
-- String.pos_add_char
@[simp] theorem pos_add_char (p : Pos) (c : Char) : (p + c).byteIdx = p.byteIdx + c.utf8Size 
Arguments: (p : String.Pos) (c : Char)
Goal: (p + c).byteIdx = p.byteIdx + c.utf8Size
-- String.lt_next
theorem lt_next (s : String) (i : Pos) : i.1 < (s.next i).1 
Arguments: (s : String) (i : String.Pos)
Goal: i.byteIdx < (s.next i).byteIdx
-- String.utf8PrevAux_lt_of_pos
theorem utf8PrevAux_lt_of_pos : ∀ (cs : List Char) (i p : Pos), p ≠ 0 →
    (utf8PrevAux cs i p).1 < p.1
  
Arguments: (cs : List Char) (i p : String.Pos)
Goal: p ≠ 0 → (String.utf8PrevAux cs i p).byteIdx < p.byteIdx
-- String.prev_lt_of_pos
theorem prev_lt_of_pos (s : String) (i : Pos) (h : i ≠ 0) : (s.prev i).1 < i.1 
Arguments: (s : String) (i : String.Pos) (h : i ≠ 0)
Goal: (s.prev i).byteIdx < i.byteIdx
-- String.Iterator.sizeOf_eq
theorem Iterator.sizeOf_eq (i : String.Iterator) : sizeOf i = i.1.utf8ByteSize - i.2.byteIdx 
Arguments: (i : String.Iterator)
Goal: sizeOf i = i.s.utf8ByteSize - i.i.byteIdx
-- String.utf8SetAux_of_gt
theorem utf8SetAux_of_gt (c' : Char) : ∀ (cs : List Char) {i p : Pos}, i > p → utf8SetAux c' cs i p = cs
  
Arguments: (c' : Char) (cs : List Char) {i p : String.Pos}
Goal: i > p → String.utf8SetAux c' cs i p = cs
-- String.set_next_add
theorem set_next_add (s : String) (i : Pos) (c : Char) (b₁ b₂)
    (h : (s.next i).1 + b₁ = s.endPos.1 + b₂) :
    ((s.set i c).next i).1 + b₁ = (s.set i c).endPos.1 + b₂ 
Arguments: (s : String) (i : String.Pos) (c : Char) (b₁ b₂ : Nat) (h : (s.next i).byteIdx + b₁ = s.endPos.byteIdx + b₂)
Goal: ((s.set i c).next i).byteIdx + b₁ = (s.set i c).endPos.byteIdx + b₂
-- String.set_next_add.foo
theorem set_next_add (s : String) (i : Pos) (c : Char) (b₁ b₂)
    (h : (s.next i).1 + b₁ = s.endPos.1 + b₂) :
    ((s.set i c).next i).1 + b₁ = (s.set i c).endPos.1 + b₂ 
Arguments: (i : String.Pos) (c : Char) (cs : List Char) (a : String.Pos) (b₁ b₂ : Nat)
Goal: (String.utf8GetAux cs a i).utf8Size + b₁ = String.utf8ByteSize.go cs + b₂ →
  (String.utf8GetAux (String.utf8SetAux c cs a i) a i).utf8Size + b₁ =
    String.utf8ByteSize.go (String.utf8SetAux c cs a i) + b₂
-- String.mapAux_lemma
theorem mapAux_lemma (s : String) (i : Pos) (c : Char) (h : ¬s.atEnd i) :
    (s.set i c).endPos.1 - ((s.set i c).next i).1 < s.endPos.1 - i.1 
Arguments: (s : String) (i : String.Pos) (c : Char) (h : ¬s.atEnd i = true)
Goal: (s.set i c).endPos.byteIdx - ((s.set i c).next i).byteIdx < s.endPos.byteIdx - i.byteIdx
-- Substring.lt_next
theorem lt_next (s : Substring) (i : String.Pos) (h : i.1 < s.bsize) :
    i.1 < (s.next i).1 
Arguments: (s : Substring) (i : String.Pos) (h : i.byteIdx < s.bsize)
Goal: i.byteIdx < (s.next i).byteIdx
-- Char.length_toString
@[simp] theorem length_toString (c : Char) : c.toString.length = 1 
Arguments: (c : Char)
Goal: c.toString.length = 1
-- String.ext
theorem ext {s₁ s₂ : String} (h : s₁.data = s₂.data) : s₁ = s₂ 
Arguments: {s₁ s₂ : String} (h : s₁.data = s₂.data)
Goal: s₁ = s₂
-- String.ext_iff
theorem ext_iff {s₁ s₂ : String} : s₁ = s₂ ↔ s₁.data = s₂.data 
Arguments: {s₁ s₂ : String}
Goal: s₁ = s₂ ↔ s₁.data = s₂.data
-- String.default_eq
@[simp] theorem default_eq : default = "" 
Goal: default = ""
-- String.length_mk
@[simp] theorem length_mk (s : List Char) : (String.mk s).length = s.length 
Arguments: (s : List Char)
Goal: { data := s }.length = s.length
-- String.length_empty
@[simp] theorem length_empty : "".length = 0 
Goal: "".length = 0
-- String.length_singleton
@[simp] theorem length_singleton (c : Char) : (String.singleton c).length = 1 
Arguments: (c : Char)
Goal: (String.singleton c).length = 1
-- String.length_push
@[simp] theorem length_push (c : Char) : (String.push s c).length = s.length + 1 
Arguments: {s : String} (c : Char)
Goal: (s.push c).length = s.length + 1
-- String.length_pushn
@[simp] theorem length_pushn (c : Char) (n : Nat) : (pushn s c n).length = s.length + n 
Arguments: {s : String} (c : Char) (n : Nat)
Goal: (s.pushn c n).length = s.length + n
-- String.length_append
@[simp] theorem length_append (s t : String) : (s ++ t).length = s.length + t.length 
Arguments: (s t : String)
Goal: (s ++ t).length = s.length + t.length
-- String.data_push
@[simp] theorem data_push (s : String) (c : Char) : (s.push c).data = s.data ++ [c] 
Arguments: (s : String) (c : Char)
Goal: (s.push c).data = s.data ++ c :: List.nil
-- String.data_append
@[simp] theorem data_append (s t : String) : (s ++ t).data = s.data ++ t.data 
Arguments: (s t : String)
Goal: (s ++ t).data = s.data ++ t.data
-- String.lt_iff
theorem lt_iff (s t : String) : s < t ↔ s.data < t.data 
Arguments: (s t : String)
Goal: s < t ↔ s.data < t.data
-- String.Pos.byteIdx_zero
@[simp] theorem byteIdx_zero : (0 : Pos).byteIdx = 0 
Goal: String.Pos.byteIdx 0 = 0
-- String.Pos.byteIdx_mk
theorem byteIdx_mk (n : Nat) : byteIdx ⟨n⟩ = n 
Arguments: (n : Nat)
Goal: { byteIdx := n }.byteIdx = n
-- String.Pos.mk_zero
@[simp] theorem mk_zero : ⟨0⟩ = (0 : Pos) 
Goal: { byteIdx := 0 } = 0
-- String.Pos.mk_byteIdx
@[simp] theorem mk_byteIdx (p : Pos) : ⟨p.byteIdx⟩ = p 
Arguments: (p : String.Pos)
Goal: { byteIdx := p.byteIdx } = p
-- String.Pos.ext
theorem ext {i₁ i₂ : Pos} (h : i₁.byteIdx = i₂.byteIdx) : i₁ = i₂ 
Arguments: {i₁ i₂ : String.Pos} (h : i₁.byteIdx = i₂.byteIdx)
Goal: i₁ = i₂
-- String.Pos.ext_iff
theorem ext_iff {i₁ i₂ : Pos} : i₁ = i₂ ↔ i₁.byteIdx = i₂.byteIdx 
Arguments: {i₁ i₂ : String.Pos}
Goal: i₁ = i₂ ↔ i₁.byteIdx = i₂.byteIdx
-- String.Pos.add_byteIdx
@[simp] theorem add_byteIdx (p₁ p₂ : Pos) : (p₁ + p₂).byteIdx = p₁.byteIdx + p₂.byteIdx 
Arguments: (p₁ p₂ : String.Pos)
Goal: (p₁ + p₂).byteIdx = p₁.byteIdx + p₂.byteIdx
-- String.Pos.add_eq
theorem add_eq (p₁ p₂ : Pos) : p₁ + p₂ = ⟨p₁.byteIdx + p₂.byteIdx⟩ 
Arguments: (p₁ p₂ : String.Pos)
Goal: p₁ + p₂ = { byteIdx := p₁.byteIdx + p₂.byteIdx }
-- String.Pos.sub_byteIdx
@[simp] theorem sub_byteIdx (p₁ p₂ : Pos) : (p₁ - p₂).byteIdx = p₁.byteIdx - p₂.byteIdx 
Arguments: (p₁ p₂ : String.Pos)
Goal: (p₁ - p₂).byteIdx = p₁.byteIdx - p₂.byteIdx
-- String.Pos.sub_eq
theorem sub_eq (p₁ p₂ : Pos) : p₁ - p₂ = ⟨p₁.byteIdx - p₂.byteIdx⟩ 
Arguments: (p₁ p₂ : String.Pos)
Goal: p₁ - p₂ = { byteIdx := p₁.byteIdx - p₂.byteIdx }
-- String.Pos.addChar_byteIdx
@[simp] theorem addChar_byteIdx (p : Pos) (c : Char) : (p + c).byteIdx = p.byteIdx + c.utf8Size 
Arguments: (p : String.Pos) (c : Char)
Goal: (p + c).byteIdx = p.byteIdx + c.utf8Size
-- String.Pos.addChar_eq
theorem addChar_eq (p : Pos) (c : Char) : p + c = ⟨p.byteIdx + c.utf8Size⟩ 
Arguments: (p : String.Pos) (c : Char)
Goal: p + c = { byteIdx := p.byteIdx + c.utf8Size }
-- String.Pos.zero_addChar_byteIdx
theorem zero_addChar_byteIdx (c : Char) : ((0 : Pos) + c).byteIdx = c.utf8Size 
Arguments: (c : Char)
Goal: (0 + c).byteIdx = c.utf8Size
-- String.Pos.zero_addChar_eq
theorem zero_addChar_eq (c : Char) : (0 : Pos) + c = ⟨c.utf8Size⟩ 
Arguments: (c : Char)
Goal: 0 + c = { byteIdx := c.utf8Size }
-- String.Pos.addChar_right_comm
theorem addChar_right_comm (p : Pos) (c₁ c₂ : Char) : p + c₁ + c₂ = p + c₂ + c₁ 
Arguments: (p : String.Pos) (c₁ c₂ : Char)
Goal: p + c₁ + c₂ = p + c₂ + c₁
-- String.Pos.ne_of_lt
theorem ne_of_lt {i₁ i₂ : Pos} (h : i₁ < i₂) : i₁ ≠ i₂ 
Arguments: {i₁ i₂ : String.Pos} (h : i₁ < i₂)
Goal: i₁ ≠ i₂
-- String.Pos.ne_of_gt
theorem ne_of_gt {i₁ i₂ : Pos} (h : i₁ < i₂) : i₂ ≠ i₁ 
Arguments: {i₁ i₂ : String.Pos} (h : i₁ < i₂)
Goal: i₂ ≠ i₁
-- String.Pos.addString_byteIdx
@[simp] theorem addString_byteIdx (p : Pos) (s : String) :
    (p + s).byteIdx = p.byteIdx + s.utf8ByteSize 
Arguments: (p : String.Pos) (s : String)
Goal: (p + s).byteIdx = p.byteIdx + s.utf8ByteSize
-- String.Pos.addString_eq
theorem addString_eq (p : Pos) (s : String) : p + s = ⟨p.byteIdx + s.utf8ByteSize⟩ 
Arguments: (p : String.Pos) (s : String)
Goal: p + s = { byteIdx := p.byteIdx + s.utf8ByteSize }
-- String.Pos.zero_addString_byteIdx
theorem zero_addString_byteIdx (s : String) : ((0 : Pos) + s).byteIdx = s.utf8ByteSize 
Arguments: (s : String)
Goal: (0 + s).byteIdx = s.utf8ByteSize
-- String.Pos.zero_addString_eq
theorem zero_addString_eq (s : String) : (0 : Pos) + s = ⟨s.utf8ByteSize⟩ 
Arguments: (s : String)
Goal: 0 + s = { byteIdx := s.utf8ByteSize }
-- String.Pos.le_iff
theorem le_iff {i₁ i₂ : Pos} : i₁ ≤ i₂ ↔ i₁.byteIdx ≤ i₂.byteIdx 
Arguments: {i₁ i₂ : String.Pos}
Goal: i₁ ≤ i₂ ↔ i₁.byteIdx ≤ i₂.byteIdx
-- String.Pos.mk_le_mk
@[simp] theorem mk_le_mk {i₁ i₂ : Nat} : Pos.mk i₁ ≤ Pos.mk i₂ ↔ i₁ ≤ i₂ 
Arguments: {i₁ i₂ : Nat}
Goal: { byteIdx := i₁ } ≤ { byteIdx := i₂ } ↔ i₁ ≤ i₂
-- String.Pos.lt_iff
theorem lt_iff {i₁ i₂ : Pos} : i₁ < i₂ ↔ i₁.byteIdx < i₂.byteIdx 
Arguments: {i₁ i₂ : String.Pos}
Goal: i₁ < i₂ ↔ i₁.byteIdx < i₂.byteIdx
-- String.Pos.mk_lt_mk
@[simp] theorem mk_lt_mk {i₁ i₂ : Nat} : Pos.mk i₁ < Pos.mk i₂ ↔ i₁ < i₂ 
Arguments: {i₁ i₂ : Nat}
Goal: { byteIdx := i₁ } < { byteIdx := i₂ } ↔ i₁ < i₂
-- String.get!_eq_get
@[simp] theorem get!_eq_get (s : String) (p : Pos) : get! s p = get s p 
Arguments: (s : String) (p : String.Pos)
Goal: s.get! p = s.get p
-- String.lt_next'
theorem lt_next' (s : String) (p : Pos) : p < next s p 
Arguments: (s : String) (p : String.Pos)
Goal: p < s.next p
-- String.prev_zero
@[simp] theorem prev_zero (s : String) : prev s 0 = 0 
Arguments: (s : String)
Goal: s.prev 0 = 0
-- String.get'_eq
@[simp] theorem get'_eq (s : String) (p : Pos) (h) : get' s p h = get s p 
Arguments: (s : String) (p : String.Pos) (h : ¬s.atEnd p = true)
Goal: s.get' p h = s.get p
-- String.next'_eq
@[simp] theorem next'_eq (s : String) (p : Pos) (h) : next' s p h = next s p 
Arguments: (s : String) (p : String.Pos) (h : ¬s.atEnd p = true)
Goal: s.next' p h = s.next p
-- String.singleton_eq
theorem singleton_eq (c : Char) : singleton c = ⟨[c]⟩ 
Arguments: (c : Char)
Goal: String.singleton c = { data := c :: List.nil }
-- String.data_singleton
@[simp] theorem data_singleton (c : Char) : (singleton c).data = [c] 
Arguments: (c : Char)
Goal: (String.singleton c).data = c :: List.nil
-- String.append_empty
@[simp] theorem append_empty (s : String) : s ++ "" = s 
Arguments: (s : String)
Goal: s ++ "" = s
-- String.empty_append
@[simp] theorem empty_append (s : String) : "" ++ s = s 
Arguments: (s : String)
Goal: "" ++ s = s
-- String.append_assoc
theorem append_assoc (s₁ s₂ s₃ : String) : (s₁ ++ s₂) ++ s₃ = s₁ ++ (s₂ ++ s₃) 
Arguments: (s₁ s₂ s₃ : String)
Goal: s₁ ++ s₂ ++ s₃ = s₁ ++ (s₂ ++ s₃)
-- Substring.prev_zero
@[simp] theorem prev_zero (s : Substring) : s.prev 0 = 0 
Arguments: (s : Substring)
Goal: s.prev 0 = 0
-- Substring.prevn_zero
@[simp] theorem prevn_zero (s : Substring) : ∀ n, s.prevn n 0 = 0
  
Arguments: (s : Substring) (n : Nat)
Goal: s.prevn n 0 = 0
-- Lake.ModuleFacet.data_eq
structure ModuleFacet (α) where
    name : Name
    data_eq : ModuleData name = α
  deriving Repr
Arguments: {α : Type} (self : Lake.ModuleFacet α)
Goal: Lake.ModuleData self.name = α
-- Lake.BuildKey.eq_of_quickCmp
theorem eq_of_quickCmp {k k' : BuildKey}  :
quickCmp k k' = Ordering.eq → k = k' 
Arguments: {k k' : Lake.BuildKey}
Goal: k.quickCmp k' = Ordering.eq → k = k'
-- Nat.Linear.Poly.denote_insertSorted
theorem Poly.denote_insertSorted (ctx : Context) (k : Nat) (v : Var) (p : Poly) : (p.insertSorted k v).denote ctx = p.denote ctx + k * v.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (k : Nat) (v : Nat.Linear.Var) (p : Nat.Linear.Poly)
Goal: Nat.Linear.Poly.denote ctx (Nat.Linear.Poly.insertSorted k v p) =
  Nat.Linear.Poly.denote ctx p + k * Nat.Linear.Var.denote ctx v
-- Nat.Linear.Poly.denote_sort_go
theorem Poly.denote_sort_go (ctx : Context) (p : Poly) (r : Poly) : (sort.go p r).denote ctx = p.denote ctx + r.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (p r : Nat.Linear.Poly)
Goal: Nat.Linear.Poly.denote ctx (Nat.Linear.Poly.sort.go p r) = Nat.Linear.Poly.denote ctx p + Nat.Linear.Poly.denote ctx r
-- Nat.Linear.Poly.denote_sort
theorem Poly.denote_sort (ctx : Context) (m : Poly) : m.sort.denote ctx = m.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (m : Nat.Linear.Poly)
Goal: Nat.Linear.Poly.denote ctx m.sort = Nat.Linear.Poly.denote ctx m
-- Nat.Linear.Poly.denote_append
theorem Poly.denote_append (ctx : Context) (p q : Poly) : (p ++ q).denote ctx = p.denote ctx + q.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (p q : Nat.Linear.Poly)
Goal: Nat.Linear.Poly.denote ctx (p ++ q) = Nat.Linear.Poly.denote ctx p + Nat.Linear.Poly.denote ctx q
-- Nat.Linear.Poly.denote_cons
theorem Poly.denote_cons (ctx : Context) (k : Nat) (v : Var) (p : Poly) : denote ctx ((k, v) :: p) = k * v.denote ctx + p.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (k : Nat) (v : Nat.Linear.Var) (p : Nat.Linear.Poly)
Goal: Nat.Linear.Poly.denote ctx ((k, v) :: p) = k * Nat.Linear.Var.denote ctx v + Nat.Linear.Poly.denote ctx p
-- Nat.Linear.Poly.denote_reverseAux
theorem Poly.denote_reverseAux (ctx : Context) (p q : Poly) : denote ctx (List.reverseAux p q) = denote ctx (p ++ q) 
Arguments: (ctx : Nat.Linear.Context) (p q : Nat.Linear.Poly)
Goal: Nat.Linear.Poly.denote ctx (List.reverseAux p q) = Nat.Linear.Poly.denote ctx (p ++ q)
-- Nat.Linear.Poly.denote_reverse
theorem Poly.denote_reverse (ctx : Context) (p : Poly) : denote ctx (List.reverse p) = denote ctx p 
Arguments: (ctx : Nat.Linear.Context) (p : Nat.Linear.Poly)
Goal: Nat.Linear.Poly.denote ctx (List.reverse p) = Nat.Linear.Poly.denote ctx p
-- Nat.Linear.Poly.denote_fuse
theorem Poly.denote_fuse (ctx : Context) (p : Poly) : p.fuse.denote ctx = p.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (p : Nat.Linear.Poly)
Goal: Nat.Linear.Poly.denote ctx p.fuse = Nat.Linear.Poly.denote ctx p
-- Nat.Linear.Poly.denote_mul
theorem Poly.denote_mul (ctx : Context) (k : Nat) (p : Poly) : (p.mul k).denote ctx = k * p.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (k : Nat) (p : Nat.Linear.Poly)
Goal: Nat.Linear.Poly.denote ctx (Nat.Linear.Poly.mul k p) = k * Nat.Linear.Poly.denote ctx p