ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- String.takeWhileAux_of_valid
@[nolint unusedHavesSuffices] -- false positive from unfolding String.takeWhileAux
theorem takeWhileAux_of_valid (p : Char → Bool) : ∀ l m r,
    Substring.takeWhileAux ⟨l ++ m ++ r⟩ ⟨utf8Len l + utf8Len m⟩ p ⟨utf8Len l⟩ =
      ⟨utf8Len l + utf8Len (m.takeWhile p)⟩
  
Arguments: (p : Char → Bool) (l m r : List Char)
Goal: Substring.takeWhileAux { data := l ++ m ++ r } { byteIdx := String.utf8Len l + String.utf8Len m } p
    { byteIdx := String.utf8Len l } =
  { byteIdx := String.utf8Len l + String.utf8Len (List.takeWhile p m) }
-- Substring.Valid.stopValid
structure Valid (s : Substring) : Prop where
    startValid : s.startPos.Valid s.str
    stopValid : s.stopPos.Valid s.str
    le : s.startPos ≤ s.stopPos
Arguments: {s : Substring} (self : s.Valid)
Goal: String.Pos.Valid s.str s.stopPos
-- Substring.Valid.le
structure Valid (s : Substring) : Prop where
    startValid : s.startPos.Valid s.str
    stopValid : s.stopPos.Valid s.str
    le : s.startPos ≤ s.stopPos
Arguments: {s : Substring} (self : s.Valid)
Goal: s.startPos ≤ s.stopPos
-- Substring.Valid.startValid
structure Valid (s : Substring) : Prop where
    startValid : s.startPos.Valid s.str
    stopValid : s.stopPos.Valid s.str
    le : s.startPos ≤ s.stopPos
Arguments: {s : Substring} (self : s.Valid)
Goal: String.Pos.Valid s.str s.startPos
-- Substring.Valid_default
theorem Valid_default : Valid default 
Goal: default.Valid
-- Substring.ValidFor.valid
theorem valid : ∀ {s}, ValidFor l m r s → Valid s
  
Arguments: {l m r : List Char} {s : Substring}
Goal: Substring.ValidFor l m r s → s.Valid
-- Substring.ValidFor.of_eq
theorem of_eq : ∀ s,
    s.str.1 = l ++ m ++ r →
    s.startPos.1 = utf8Len l →
    s.stopPos.1 = utf8Len l + utf8Len m →
    ValidFor l m r s
  
Arguments: {l m r : List Char} (s : Substring)
Goal: s.str.data = l ++ m ++ r →
  s.startPos.byteIdx = String.utf8Len l →
    s.stopPos.byteIdx = String.utf8Len l + String.utf8Len m → Substring.ValidFor l m r s
-- String.validFor_toSubstring
theorem _root_.String.validFor_toSubstring (s : String) : ValidFor [] s.1 [] s 
Arguments: (s : String)
Goal: Substring.ValidFor [] s.data [] s.toSubstring
-- Substring.ValidFor.str
theorem str : ∀ {s}, ValidFor l m r s → s.str = ⟨l ++ m ++ r⟩
  
Arguments: {l m r : List Char} {s : Substring}
Goal: Substring.ValidFor l m r s → s.str = { data := l ++ m ++ r }
-- Substring.ValidFor.startPos
theorem startPos : ∀ {s}, ValidFor l m r s → s.startPos = ⟨utf8Len l⟩
  
Arguments: {l m r : List Char} {s : Substring}
Goal: Substring.ValidFor l m r s → s.startPos = { byteIdx := String.utf8Len l }
-- Substring.ValidFor.stopPos
theorem stopPos : ∀ {s}, ValidFor l m r s → s.stopPos = ⟨utf8Len l + utf8Len m⟩
  
Arguments: {l m r : List Char} {s : Substring}
Goal: Substring.ValidFor l m r s → s.stopPos = { byteIdx := String.utf8Len l + String.utf8Len m }
-- Substring.ValidFor.bsize
theorem bsize : ∀ {s}, ValidFor l m r s → s.bsize = utf8Len m
  
Arguments: {l m r : List Char} {s : Substring}
Goal: Substring.ValidFor l m r s → s.bsize = String.utf8Len m
-- Substring.ValidFor.isEmpty
theorem isEmpty : ∀ {s}, ValidFor l m r s → (s.isEmpty ↔ m = [])
  
Arguments: {l m r : List Char} {s : Substring}
Goal: Substring.ValidFor l m r s → (s.isEmpty = true ↔ m = [])
-- Substring.ValidFor.toString
theorem toString : ∀ {s}, ValidFor l m r s → s.toString = ⟨m⟩
  
Arguments: {l m r : List Char} {s : Substring}
Goal: Substring.ValidFor l m r s → s.toString = { data := m }
-- Substring.ValidFor.toIterator
theorem toIterator : ∀ {s}, ValidFor l m r s → s.toIterator.ValidFor l.reverse (m ++ r)
  
Arguments: {l m r : List Char} {s : Substring}
Goal: Substring.ValidFor l m r s → String.Iterator.ValidFor l.reverse (m ++ r) s.toIterator
-- Substring.ValidFor.get
theorem get : ∀ {s}, ValidFor l (m₁ ++ c :: m₂) r s → s.get ⟨utf8Len m₁⟩ = c
  
Arguments: {l m₁ : List Char} {c : Char} {m₂ r : List Char} {s : Substring}
Goal: Substring.ValidFor l (m₁ ++ c :: m₂) r s → s.get { byteIdx := String.utf8Len m₁ } = c
-- Substring.ValidFor.next
theorem next : ∀ {s}, ValidFor l (m₁ ++ c :: m₂) r s →
    s.next ⟨utf8Len m₁⟩ = ⟨utf8Len m₁ + c.utf8Size⟩
  
Arguments: {l m₁ : List Char} {c : Char} {m₂ r : List Char} {s : Substring}
Goal: Substring.ValidFor l (m₁ ++ c :: m₂) r s →
  s.next { byteIdx := String.utf8Len m₁ } = { byteIdx := String.utf8Len m₁ + c.utf8Size }
-- Substring.ValidFor.next_stop
theorem next_stop : ∀ {s}, ValidFor l m r s → s.next ⟨utf8Len m⟩ = ⟨utf8Len m⟩
  
Arguments: {l m r : List Char} {s : Substring}
Goal: Substring.ValidFor l m r s → s.next { byteIdx := String.utf8Len m } = { byteIdx := String.utf8Len m }
-- Substring.ValidFor.prev
theorem prev : ∀ {s}, ValidFor l (m₁ ++ c :: m₂) r s →
    s.prev ⟨utf8Len m₁ + c.utf8Size⟩ = ⟨utf8Len m₁⟩
  
Arguments: {l m₁ : List Char} {c : Char} {m₂ r : List Char} {s : Substring}
Goal: Substring.ValidFor l (m₁ ++ c :: m₂) r s →
  s.prev { byteIdx := String.utf8Len m₁ + c.utf8Size } = { byteIdx := String.utf8Len m₁ }
-- Substring.ValidFor.nextn_stop
theorem nextn_stop : ∀ {s}, ValidFor l m r s → ∀ n, s.nextn n ⟨utf8Len m⟩ = ⟨utf8Len m⟩
  
Arguments: {l m r : List Char} {s : Substring}
Goal: Substring.ValidFor l m r s → ∀ (n : Nat), s.nextn n { byteIdx := String.utf8Len m } = { byteIdx := String.utf8Len m }
-- Substring.ValidFor.nextn
theorem nextn : ∀ {s}, ValidFor l (m₁ ++ m₂) r s →
    ∀ n, s.nextn n ⟨utf8Len m₁⟩ = ⟨utf8Len m₁ + utf8Len (m₂.take n)⟩
  
Arguments: {l m₁ m₂ r : List Char} {s : Substring}
Goal: Substring.ValidFor l (m₁ ++ m₂) r s →
  ∀ (n : Nat),
    s.nextn n { byteIdx := String.utf8Len m₁ } = { byteIdx := String.utf8Len m₁ + String.utf8Len (List.take n m₂) }
-- Substring.ValidFor.prevn
theorem prevn : ∀ {s}, ValidFor l (m₁.reverse ++ m₂) r s →
    ∀ n, s.prevn n ⟨utf8Len m₁⟩ = ⟨utf8Len (m₁.drop n)⟩
  
Arguments: {l m₂ r m₁ : List Char} {s : Substring}
Goal: Substring.ValidFor l (m₁.reverse ++ m₂) r s →
  ∀ (n : Nat), s.prevn n { byteIdx := String.utf8Len m₁ } = { byteIdx := String.utf8Len (List.drop n m₁) }
-- Substring.ValidFor.front
theorem front : ∀ {s}, ValidFor l (c :: m) r s → s.front = c
  
Arguments: {l : List Char} {c : Char} {m r : List Char} {s : Substring}
Goal: Substring.ValidFor l (c :: m) r s → s.front = c
-- Substring.ValidFor.drop
theorem drop : ∀ {s}, ValidFor l m r s → ∀ n, ValidFor (l ++ m.take n) (m.drop n) r (s.drop n)
  
Arguments: {l m r : List Char} {s : Substring}
Goal: Substring.ValidFor l m r s → ∀ (n : Nat), Substring.ValidFor (l ++ List.take n m) (List.drop n m) r (s.drop n)
-- Substring.ValidFor.take
theorem take : ∀ {s}, ValidFor l m r s → ∀ n, ValidFor l (m.take n) (m.drop n ++ r) (s.take n)
  
Arguments: {l m r : List Char} {s : Substring}
Goal: Substring.ValidFor l m r s → ∀ (n : Nat), Substring.ValidFor l (List.take n m) (List.drop n m ++ r) (s.take n)
-- Substring.ValidFor.atEnd
theorem atEnd : ∀ {s}, ValidFor l m r s → (s.atEnd ⟨p⟩ ↔ p = utf8Len m)
  
Arguments: {l m r : List Char} {p : Nat} {s : Substring}
Goal: Substring.ValidFor l m r s → (s.atEnd { byteIdx := p } = true ↔ p = String.utf8Len m)
-- Substring.ValidFor.extract
theorem extract : ∀ {s}, ValidFor l m r s → ValidFor ml mm mr ⟨⟨m⟩, b, e⟩ →
    ∃ l' r', ValidFor l' mm r' (s.extract b e)
  
Arguments: {l m r ml mm mr : List Char} {b e : String.Pos} {s : Substring}
Goal: Substring.ValidFor l m r s →
  Substring.ValidFor ml mm mr { str := { data := m }, startPos := b, stopPos := e } →
    ∃ l' r', Substring.ValidFor l' mm r' (s.extract b e)
-- Substring.ValidFor.foldl
theorem foldl (f) (init : α) : ∀ {s}, ValidFor l m r s → s.foldl f init = m.foldl f init
  
Arguments: {α : Type u_1} {l m r : List Char} (f : α → Char → α) (init : α) {s : Substring}
Goal: Substring.ValidFor l m r s → Substring.foldl f init s = List.foldl f init m
-- Substring.ValidFor.foldr
theorem foldr (f) (init : α) : ∀ {s}, ValidFor l m r s → s.foldr f init = m.foldr f init
  
Arguments: {α : Type u_1} {l m r : List Char} (f : Char → α → α) (init : α) {s : Substring}
Goal: Substring.ValidFor l m r s → Substring.foldr f init s = List.foldr f init m
-- Substring.ValidFor.any
theorem any (f) : ∀ {s}, ValidFor l m r s → s.any f = m.any f
  
Arguments: {l m r : List Char} (f : Char → Bool) {s : Substring}
Goal: Substring.ValidFor l m r s → s.any f = m.any f
-- Substring.ValidFor.all
theorem all (f) : ∀ {s}, ValidFor l m r s → s.all f = m.all f
  
Arguments: {l m r : List Char} (f : Char → Bool) {s : Substring}
Goal: Substring.ValidFor l m r s → s.all f = m.all f
-- Substring.ValidFor.contains
theorem contains (c) : ∀ {s}, ValidFor l m r s → (s.contains c ↔ c ∈ m)
  
Arguments: {l m r : List Char} (c : Char) {s : Substring}
Goal: Substring.ValidFor l m r s → (s.contains c = true ↔ c ∈ m)
-- Substring.ValidFor.takeWhile
theorem takeWhile (p : Char → Bool) : ∀ {s}, ValidFor l m r s →
    ValidFor l (m.takeWhile p) (m.dropWhile p ++ r) (s.takeWhile p)
  
Arguments: {l m r : List Char} (p : Char → Bool) {s : Substring}
Goal: Substring.ValidFor l m r s → Substring.ValidFor l (List.takeWhile p m) (List.dropWhile p m ++ r) (s.takeWhile p)
-- Substring.ValidFor.dropWhile
theorem dropWhile (p : Char → Bool) : ∀ {s}, ValidFor l m r s →
    ValidFor (l ++ m.takeWhile p) (m.dropWhile p) r (s.dropWhile p)
  
Arguments: {l m r : List Char} (p : Char → Bool) {s : Substring}
Goal: Substring.ValidFor l m r s → Substring.ValidFor (l ++ List.takeWhile p m) (List.dropWhile p m) r (s.dropWhile p)
-- Substring.Valid.validFor
theorem validFor : ∀ {s}, Valid s → ∃ l m r, ValidFor l m r s
  
Arguments: {s : Substring}
Goal: s.Valid → ∃ l m r, Substring.ValidFor l m r s
-- Substring.Valid.valid
theorem valid : ∀ {s}, ValidFor l m r s → Valid s
  
Arguments: {l m r : List Char} {s : Substring}
Goal: Substring.ValidFor l m r s → s.Valid
-- String.valid_toSubstring
theorem _root_.String.valid_toSubstring (s : String) : Valid s 
Arguments: (s : String)
Goal: s.toSubstring.Valid
-- Substring.Valid.bsize
theorem bsize : ∀ {s}, Valid s → s.bsize = utf8Len s.toString.1
  
Arguments: {s : Substring}
Goal: s.Valid → s.bsize = String.utf8Len s.toString.data
-- Substring.Valid.isEmpty
theorem isEmpty : ∀ {s}, Valid s → (s.isEmpty ↔ s.toString = "")
  
Arguments: {s : Substring}
Goal: s.Valid → (s.isEmpty = true ↔ s.toString = "")
-- Substring.Valid.get
theorem get : ∀ {s}, Valid s → s.toString.1 = m₁ ++ c :: m₂ → s.get ⟨utf8Len m₁⟩ = c
  
Arguments: {m₁ : List Char} {c : Char} {m₂ : List Char} {s : Substring}
Goal: s.Valid → s.toString.data = m₁ ++ c :: m₂ → s.get { byteIdx := String.utf8Len m₁ } = c
-- Substring.Valid.next
theorem next : ∀ {s}, Valid s → s.toString.1 = m₁ ++ c :: m₂ →
    s.next ⟨utf8Len m₁⟩ = ⟨utf8Len m₁ + c.utf8Size⟩
  
Arguments: {m₁ : List Char} {c : Char} {m₂ : List Char} {s : Substring}
Goal: s.Valid →
  s.toString.data = m₁ ++ c :: m₂ →
    s.next { byteIdx := String.utf8Len m₁ } = { byteIdx := String.utf8Len m₁ + c.utf8Size }
-- Substring.Valid.next_stop
theorem next_stop : ∀ {s}, Valid s → s.next ⟨s.bsize⟩ = ⟨s.bsize⟩
  
Arguments: {s : Substring}
Goal: s.Valid → s.next { byteIdx := s.bsize } = { byteIdx := s.bsize }
-- Substring.Valid.prev
theorem prev : ∀ {s}, Valid s → s.toString.1 = m₁ ++ c :: m₂ →
    s.prev ⟨utf8Len m₁ + c.utf8Size⟩ = ⟨utf8Len m₁⟩
  
Arguments: {m₁ : List Char} {c : Char} {m₂ : List Char} {s : Substring}
Goal: s.Valid →
  s.toString.data = m₁ ++ c :: m₂ →
    s.prev { byteIdx := String.utf8Len m₁ + c.utf8Size } = { byteIdx := String.utf8Len m₁ }
-- Substring.Valid.nextn_stop
theorem nextn_stop : ∀ {s}, Valid s → ∀ n, s.nextn n ⟨s.bsize⟩ = ⟨s.bsize⟩
  
Arguments: {s : Substring}
Goal: s.Valid → ∀ (n : Nat), s.nextn n { byteIdx := s.bsize } = { byteIdx := s.bsize }
-- Substring.Valid.nextn
theorem nextn : ∀ {s}, Valid s → s.toString.1 = m₁ ++ m₂ →
    ∀ n, s.nextn n ⟨utf8Len m₁⟩ = ⟨utf8Len m₁ + utf8Len (m₂.take n)⟩
  
Arguments: {m₁ m₂ : List Char} {s : Substring}
Goal: s.Valid →
  s.toString.data = m₁ ++ m₂ →
    ∀ (n : Nat),
      s.nextn n { byteIdx := String.utf8Len m₁ } = { byteIdx := String.utf8Len m₁ + String.utf8Len (List.take n m₂) }
-- Substring.Valid.prevn
theorem prevn : ∀ {s}, Valid s → s.toString.1 = m₁.reverse ++ m₂ →
    ∀ n, s.prevn n ⟨utf8Len m₁⟩ = ⟨utf8Len (m₁.drop n)⟩
  
Arguments: {m₂ m₁ : List Char} {s : Substring}
Goal: s.Valid →
  s.toString.data = m₁.reverse ++ m₂ →
    ∀ (n : Nat), s.prevn n { byteIdx := String.utf8Len m₁ } = { byteIdx := String.utf8Len (List.drop n m₁) }
-- Substring.Valid.front
theorem front : ∀ {s}, Valid s → s.toString.1 = c :: m → s.front = c
  
Arguments: {c : Char} {m : List Char} {s : Substring}
Goal: s.Valid → s.toString.data = c :: m → s.front = c
-- Substring.Valid.drop
theorem drop : ∀ {s}, Valid s → ∀ n, Valid (s.drop n)
  
Arguments: {s : Substring}
Goal: s.Valid → ∀ (n : Nat), (s.drop n).Valid
-- Substring.Valid.data_drop
theorem data_drop : ∀ {s}, Valid s → ∀ n, (s.drop n).toString.1 = s.toString.1.drop n
  
Arguments: {s : Substring}
Goal: s.Valid → ∀ (n : Nat), (s.drop n).toString.data = List.drop n s.toString.data
-- Substring.Valid.take
theorem take : ∀ {s}, Valid s → ∀ n, Valid (s.take n)
  
Arguments: {s : Substring}
Goal: s.Valid → ∀ (n : Nat), (s.take n).Valid
-- Substring.Valid.data_take
theorem data_take : ∀ {s}, Valid s → ∀ n, (s.take n).toString.1 = s.toString.1.take n
  
Arguments: {s : Substring}
Goal: s.Valid → ∀ (n : Nat), (s.take n).toString.data = List.take n s.toString.data
-- Substring.Valid.atEnd
theorem atEnd : ∀ {s}, Valid s → (s.atEnd ⟨p⟩ ↔ p = utf8ByteSize s.toString)
  
Arguments: {p : Nat} {s : Substring}
Goal: s.Valid → (s.atEnd { byteIdx := p } = true ↔ p = s.toString.utf8ByteSize)
-- Substring.Valid.extract
theorem extract : ∀ {s}, Valid s → Valid ⟨s.toString, b, e⟩ → Valid (s.extract b e)
  
Arguments: {b e : String.Pos} {s : Substring}
Goal: s.Valid → { str := s.toString, startPos := b, stopPos := e }.Valid → (s.extract b e).Valid
-- Substring.Valid.toString_extract
theorem toString_extract : ∀ {s}, Valid s → Valid ⟨s.toString, b, e⟩ →
    (s.extract b e).toString = s.toString.extract b e
  
Arguments: {b e : String.Pos} {s : Substring}
Goal: s.Valid → { str := s.toString, startPos := b, stopPos := e }.Valid → (s.extract b e).toString = s.toString.extract b e
-- Substring.Valid.foldl
theorem foldl (f) (init : α) : ∀ {s}, Valid s → s.foldl f init = s.toString.1.foldl f init
  
Arguments: {α : Type u_1} (f : α → Char → α) (init : α) {s : Substring}
Goal: s.Valid → Substring.foldl f init s = List.foldl f init s.toString.data
-- Substring.Valid.foldr
theorem foldr (f) (init : α) : ∀ {s}, Valid s → s.foldr f init = s.toString.1.foldr f init
  
Arguments: {α : Type u_1} (f : Char → α → α) (init : α) {s : Substring}
Goal: s.Valid → Substring.foldr f init s = List.foldr f init s.toString.data
-- Substring.Valid.any
theorem any (f) : ∀ {s}, Valid s → s.any f = s.toString.1.any f
  
Arguments: (f : Char → Bool) {s : Substring}
Goal: s.Valid → s.any f = s.toString.data.any f
-- Substring.Valid.all
theorem all (f) : ∀ {s}, Valid s → s.all f = s.toString.1.all f
  
Arguments: (f : Char → Bool) {s : Substring}
Goal: s.Valid → s.all f = s.toString.data.all f
-- Substring.Valid.contains
theorem contains (c) : ∀ {s}, Valid s → (s.contains c ↔ c ∈ s.toString.1)
  
Arguments: (c : Char) {s : Substring}
Goal: s.Valid → (s.contains c = true ↔ c ∈ s.toString.data)
-- Substring.Valid.takeWhile
theorem takeWhile (p : Char → Bool) : ∀ {s}, Valid s → Valid (s.takeWhile p)
  
Arguments: (p : Char → Bool) {s : Substring}
Goal: s.Valid → (s.takeWhile p).Valid
-- Substring.Valid.data_takeWhile
theorem data_takeWhile (p) : ∀ {s}, Valid s →
    (s.takeWhile p).toString.1 = s.toString.1.takeWhile p
  
Arguments: (p : Char → Bool) {s : Substring}
Goal: s.Valid → (s.takeWhile p).toString.data = List.takeWhile p s.toString.data
-- Substring.Valid.dropWhile
theorem dropWhile (p : Char → Bool) : ∀ {s}, Valid s → Valid (s.dropWhile p)
  
Arguments: (p : Char → Bool) {s : Substring}
Goal: s.Valid → (s.dropWhile p).Valid
-- Substring.Valid.data_dropWhile
theorem data_dropWhile (p) : ∀ {s}, Valid s →
    (s.dropWhile p).toString.1 = s.toString.1.dropWhile p
  
Arguments: (p : Char → Bool) {s : Substring}
Goal: s.Valid → (s.dropWhile p).toString.data = List.dropWhile p s.toString.data
-- String.drop_eq
theorem drop_eq (s : String) (n : Nat) : s.drop n = ⟨s.1.drop n⟩ 
Arguments: (s : String) (n : Nat)
Goal: s.drop n = { data := List.drop n s.data }
-- String.data_drop
@[simp] theorem data_drop (s : String) (n : Nat) : (s.drop n).1 = s.1.drop n 
Arguments: (s : String) (n : Nat)
Goal: (s.drop n).data = List.drop n s.data
-- String.drop_empty
@[simp] theorem drop_empty {n : Nat} : "".drop n = "" 
Arguments: {n : Nat}
Goal: "".drop n = ""
-- String.take_eq
theorem take_eq (s : String) (n : Nat) : s.take n = ⟨s.1.take n⟩ 
Arguments: (s : String) (n : Nat)
Goal: s.take n = { data := List.take n s.data }
-- String.data_take
@[simp] theorem data_take (s : String) (n : Nat) : (s.take n).1 = s.1.take n 
Arguments: (s : String) (n : Nat)
Goal: (s.take n).data = List.take n s.data
-- String.takeWhile_eq
theorem takeWhile_eq (p : Char → Bool) (s : String) : s.takeWhile p = ⟨s.1.takeWhile p⟩ 
Arguments: (p : Char → Bool) (s : String)
Goal: s.takeWhile p = { data := List.takeWhile p s.data }
-- String.data_takeWhile
@[simp] theorem data_takeWhile (p : Char → Bool) (s : String) :
    (s.takeWhile p).1 = s.1.takeWhile p 
Arguments: (p : Char → Bool) (s : String)
Goal: (s.takeWhile p).data = List.takeWhile p s.data
-- String.dropWhile_eq
theorem dropWhile_eq (p : Char → Bool) (s : String) : s.dropWhile p = ⟨s.1.dropWhile p⟩ 
Arguments: (p : Char → Bool) (s : String)
Goal: s.dropWhile p = { data := List.dropWhile p s.data }
-- String.data_dropWhile
@[simp] theorem data_dropWhile (p : Char → Bool) (s : String) :
    (s.dropWhile p).1 = s.1.dropWhile p 
Arguments: (p : Char → Bool) (s : String)
Goal: (s.dropWhile p).data = List.dropWhile p s.data
-- List.foldlM_nil
@[simp] theorem foldlM_nil [Monad m] (f : β → α → m β) (b) : [].foldlM f b = pure b 
Arguments: {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} [Monad m] (f : β → α → m β) (b : β)
Goal: List.foldlM f b List.nil = pure b
-- List.foldlM_cons
@[simp] theorem foldlM_cons [Monad m] (f : β → α → m β) (b) (a) (l : List α) :
    (a :: l).foldlM f b = f b a >>= l.foldlM f 
Arguments: {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} [Monad m] (f : β → α → m β) (b : β) (a : α) (l : List α)
Goal: List.foldlM f b (a :: l) = do
  let init ← f b a
  List.foldlM f init l
-- List.foldrM_nil
@[simp] theorem foldrM_nil [Monad m] (f : α → β → m β) (b) : [].foldrM f b = pure b 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] (f : α → β → m β) (b : β)
Goal: List.foldrM f b List.nil = pure b
-- List.forIn_nil
@[simp] theorem forIn_nil [Monad m] (f : α → β → m (ForInStep β)) (b : β) : forIn [] b f = pure b 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] (f : α → β → m (ForInStep β)) (b : β)
Goal: forIn List.nil b f = pure b
-- List.forIn_cons
@[simp] theorem forIn_cons [Monad m] (f : α → β → m (ForInStep β)) (a : α) (as : List α) (b : β)
    : forIn (a::as) b f = f a b >>= fun | ForInStep.done b => pure b | ForInStep.yield b => forIn as b f 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] (f : α → β → m (ForInStep β)) (a : α) (as : List α) (b : β)
Goal: forIn (a :: as) b f = do
  let x ← f a b
  match x with
    | ForInStep.done b => pure b
    | ForInStep.yield b => forIn as b f
-- List.forIn'_eq_forIn
@[simp] theorem forIn'_eq_forIn {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (as : List α) (init : β) (f : α → β → m (ForInStep β)) : forIn' as init (fun a _ b => f a b) = forIn as init f 
Arguments: {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (as : List α) (init : β) (f : α → β → m (ForInStep β))
Goal: (forIn' as init fun a x b => f a b) = forIn as init f
-- List.forM_nil
@[simp] theorem forM_nil  [Monad m] (f : α → m PUnit) : forM [] f = pure ⟨⟩ 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} [Monad m] (f : α → m PUnit)
Goal: forM List.nil f = pure PUnit.unit
-- List.forM_cons
@[simp] theorem forM_cons [Monad m] (f : α → m PUnit) (a : α) (as : List α) : forM (a::as) f = f a >>= fun _ => forM as f 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} [Monad m] (f : α → m PUnit) (a : α) (as : List α)
Goal: forM (a :: as) f = do
  f a
  forM as f
-- List.get!_nil
theorem get!_nil [Inhabited α] (n : Nat) : [].get! n = (default : α) 
Arguments: {α : Type u_1} [Inhabited α] (n : Nat)
Goal: [].get! n = default
-- List.get!_cons_succ
theorem get!_cons_succ [Inhabited α] (l : List α) (a : α) (n : Nat) :
    (a::l).get! (n+1) = get! l n 
Arguments: {α : Type u_1} [Inhabited α] (l : List α) (a : α) (n : Nat)
Goal: (a :: l).get! (n + 1) = l.get! n
-- List.get!_cons_zero
theorem get!_cons_zero [Inhabited α] (l : List α) (a : α) : (a::l).get! 0 = a 
Arguments: {α : Type u_1} [Inhabited α] (l : List α) (a : α)
Goal: (a :: l).get! 0 = a
-- List.tail!_cons
@[simp] theorem tail!_cons : @tail! α (a::l) = l 
Arguments: {α : Type u_1} {a : α} {l : List α}
Goal: (a :: l).tail! = l
-- List.getElem_append_left
theorem getElem_append_left (as bs : List α) (h : i < as.length) {h'} : (as ++ bs)[i] = as[i] 
Arguments: {α : Type u_1} {i : Nat} (as bs : List α) (h : i < as.length) {h' : i < (as ++ bs).length}
Goal: (as ++ bs)[i] = as[i]
-- List.getElem_append_right
theorem getElem_append_right (as bs : List α) (h : ¬ i < as.length) {h' h''} : (as ++ bs)[i]'h' = bs[i - as.length]'h'' 
Arguments: {α : Type u_1} {i : Nat} (as bs : List α) (h : ¬i < as.length) {h' : i < (as ++ bs).length} {h'' : i - as.length < bs.length}
Goal: (as ++ bs)[i] = bs[i - as.length]
-- List.get_last
theorem get_last {as : List α} {i : Fin (length (as ++ [a]))} (h : ¬ i.1 < as.length) : (as ++ [a] : List _).get i = a 
Arguments: {α : Type u_1} {a : α} {as : List α} {i : Fin (as ++ [a]).length} (h : ¬↑i < as.length)
Goal: (as ++ [a]).get i = a
-- List.sizeOf_lt_of_mem
theorem sizeOf_lt_of_mem [SizeOf α] {as : List α} (h : a ∈ as) : sizeOf a < sizeOf as 
Arguments: {α : Type u_1} {a : α} [SizeOf α] {as : List α} (h : a ∈ as)
Goal: sizeOf a < sizeOf as
-- List.append_cancel_left
theorem append_cancel_left {as bs cs : List α} (h : as ++ bs = as ++ cs) : bs = cs 
Arguments: {α : Type u_1} {as bs cs : List α} (h : as ++ bs = as ++ cs)
Goal: bs = cs
-- List.append_cancel_right
theorem append_cancel_right {as bs cs : List α} (h : as ++ bs = cs ++ bs) : as = cs 
Arguments: {α : Type u_1} {as bs cs : List α} (h : as ++ bs = cs ++ bs)
Goal: as = cs
-- List.append_cancel_left_eq
@[simp] theorem append_cancel_left_eq (as bs cs : List α) : (as ++ bs = as ++ cs) = (bs = cs) 
Arguments: {α : Type u_1} (as bs cs : List α)
Goal: (as ++ bs = as ++ cs) = (bs = cs)
-- List.append_cancel_right_eq
@[simp] theorem append_cancel_right_eq (as bs cs : List α) : (as ++ bs = cs ++ bs) = (as = cs) 
Arguments: {α : Type u_1} (as bs cs : List α)
Goal: (as ++ bs = cs ++ bs) = (as = cs)
-- List.sizeOf_get
@[simp] theorem sizeOf_get [SizeOf α] (as : List α) (i : Fin as.length) : sizeOf (as.get i) < sizeOf as 
Arguments: {α : Type u_1} [SizeOf α] (as : List α) (i : Fin as.length)
Goal: sizeOf (as.get i) < sizeOf as
-- List.le_antisymm
theorem le_antisymm [LT α] [s : Antisymm (¬ · < · : α → α → Prop)] {as bs : List α} (h₁ : as ≤ bs) (h₂ : bs ≤ as) : as = bs 
Arguments: {α : Type u_1} [LT α] [s : Antisymm fun x x_1 => ¬x < x_1] {as bs : List α} (h₁ : as ≤ bs) (h₂ : bs ≤ as)
Goal: as = bs
-- Lean.Name.beq_iff_eq
protected theorem beq_iff_eq {m n : Name} : m == n ↔ m = n 
Arguments: {m n : Lean.Name}
Goal: (m == n) = true ↔ m = n
-- usize_size_gt_zero
theorem usize_size_gt_zero : USize.size > 0 
Goal: USize.size > 0
-- Int.subNatNat_of_sub_eq_zero
theorem subNatNat_of_sub_eq_zero {m n : Nat} (h : n - m = 0) : subNatNat m n = ↑(m - n) 
Arguments: {m n : Nat} (h : n - m = 0)
Goal: Int.subNatNat m n = ↑(m - n)
-- Int.subNatNat_of_sub_eq_succ
theorem subNatNat_of_sub_eq_succ {m n k : Nat} (h : n - m = succ k) : subNatNat m n = -[k+1] 
Arguments: {m n k : Nat} (h : n - m = k.succ)
Goal: Int.subNatNat m n = Int.negSucc k
-- Int.neg_zero
@[simp] protected theorem neg_zero : -(0:Int) = 0 
Goal: -0 = 0
-- Int.ofNat_add
@[norm_cast] theorem ofNat_add (n m : Nat) : (↑(n + m) : Int) = n + m 
Arguments: (n m : Nat)
Goal: ↑(n + m) = ↑n + ↑m