ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.forall_mem_pwFilter
theorem forall_mem_pwFilter [DecidableRel (α := α) R]
    (neg_trans : ∀ {x y z}, R x z → R x y ∨ R y z) (a : α) (l : List α) :
    (∀ b ∈ pwFilter R l, R a b) ↔ ∀ b ∈ l, R a b 
Arguments: {α : Type u_1} {R : α → α → Prop} [DecidableRel R] (neg_trans : ∀ {x y z : α}, R x z → R x y ∨ R y z) (a : α) (l : List α)
Goal: (∀ (b : α), b ∈ List.pwFilter R l → R a b) ↔ ∀ (b : α), b ∈ l → R a b
-- Batteries.AssocList.empty_eq
@[simp] theorem empty_eq : (∅ : AssocList α β) = nil 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: ∅ = Batteries.AssocList.nil
-- Batteries.AssocList.isEmpty_eq
@[simp] theorem isEmpty_eq (l : AssocList α β) : isEmpty l = l.toList.isEmpty 
Arguments: {α : Type u_1} {β : Type u_2} (l : Batteries.AssocList α β)
Goal: l.isEmpty = l.toList.isEmpty
-- Batteries.AssocList.length_nil
@[simp] theorem length_nil : length (nil : AssocList α β) = 0 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: Batteries.AssocList.nil.length = 0
-- Batteries.AssocList.length_cons
@[simp] theorem length_cons : length (cons a b t) = length t + 1 
Goal: ∀ {α : Type u_1} {a : α} {β : Type u_2} {b : β} {t : Batteries.AssocList α β},
  (Batteries.AssocList.cons a b t).length = t.length + 1
-- Batteries.AssocList.length_toList
theorem length_toList (l : AssocList α β) : l.toList.length = l.length 
Arguments: {α : Type u_1} {β : Type u_2} (l : Batteries.AssocList α β)
Goal: l.toList.length = l.length
-- Batteries.AssocList.foldlM_eq
@[simp] theorem foldlM_eq [Monad m] (f : δ → α → β → m δ) (init l) :
    foldlM f init l = l.toList.foldlM (fun d (a, b) => f d a b) init 
Arguments: {m : Type u_1 → Type u_2} {δ : Type u_1} {α : Type u_3} {β : Type u_4} [Monad m] (f : δ → α → β → m δ) (init : δ) (l : Batteries.AssocList α β)
Goal: Batteries.AssocList.foldlM f init l =
  List.foldlM
    (fun d x =>
      match x with
      | (a, b) => f d a b)
    init l.toList
-- Batteries.AssocList.foldl_eq
@[simp] theorem foldl_eq (f : δ → α → β → δ) (init l) :
    foldl f init l = l.toList.foldl (fun d (a, b) => f d a b) init 
Arguments: {δ : Type u_1} {α : Type u_2} {β : Type u_3} (f : δ → α → β → δ) (init : δ) (l : Batteries.AssocList α β)
Goal: Batteries.AssocList.foldl f init l =
  List.foldl
    (fun d x =>
      match x with
      | (a, b) => f d a b)
    init l.toList
-- Batteries.AssocList.toList_eq_toListTR
@[csimp] theorem toList_eq_toListTR : @toList = @toListTR 
Goal: @Batteries.AssocList.toList = @Batteries.AssocList.toListTR
-- Batteries.AssocList.forM_eq
@[simp] theorem forM_eq [Monad m] (f : α → β → m PUnit) (l) :
    forM f l = l.toList.forM (fun (a, b) => f a b) 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_4} [Monad m] (f : α → β → m PUnit) (l : Batteries.AssocList α β)
Goal: Batteries.AssocList.forM f l =
  l.toList.forM fun x =>
    match x with
    | (a, b) => f a b
-- Batteries.AssocList.toList_mapKey
@[simp] theorem toList_mapKey (f : α → δ) (l : AssocList α β) :
    (mapKey f l).toList = l.toList.map (fun (a, b) => (f a, b)) 
Arguments: {α : Type u_1} {δ : Type u_2} {β : Type u_3} (f : α → δ) (l : Batteries.AssocList α β)
Goal: (Batteries.AssocList.mapKey f l).toList =
  List.map
    (fun x =>
      match x with
      | (a, b) => (f a, b))
    l.toList
-- Batteries.AssocList.length_mapKey
@[simp] theorem length_mapKey : (mapKey f l).length = l.length 
Goal: ∀ {α : Type u_1} {α_1 : Type u_2} {f : α → α_1} {β : Type u_3} {l : Batteries.AssocList α β},
  (Batteries.AssocList.mapKey f l).length = l.length
-- Batteries.AssocList.toList_mapVal
@[simp] theorem toList_mapVal (f : α → β → δ) (l : AssocList α β) :
    (mapVal f l).toList = l.toList.map (fun (a, b) => (a, f a b)) 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_3} (f : α → β → δ) (l : Batteries.AssocList α β)
Goal: (Batteries.AssocList.mapVal f l).toList =
  List.map
    (fun x =>
      match x with
      | (a, b) => (a, f a b))
    l.toList
-- Batteries.AssocList.length_mapVal
@[simp] theorem length_mapVal : (mapVal f l).length = l.length 
Goal: ∀ {α : Type u_1} {β : Type u_2} {β_1 : Type u_3} {f : α → β → β_1} {l : Batteries.AssocList α β},
  (Batteries.AssocList.mapVal f l).length = l.length
-- Batteries.AssocList.findEntryP?_eq
@[simp] theorem findEntryP?_eq (p : α → β → Bool) (l : AssocList α β) :
    findEntryP? p l = l.toList.find? fun (a, b) => p a b 
Arguments: {α : Type u_1} {β : Type u_2} (p : α → β → Bool) (l : Batteries.AssocList α β)
Goal: Batteries.AssocList.findEntryP? p l =
  List.find?
    (fun x =>
      match x with
      | (a, b) => p a b)
    l.toList
-- Batteries.AssocList.findEntry?_eq
@[simp] theorem findEntry?_eq [BEq α] (a : α) (l : AssocList α β) :
    findEntry? a l = l.toList.find? (·.1 == a) 
Arguments: {α : Type u_1} {β : Type u_2} [BEq α] (a : α) (l : Batteries.AssocList α β)
Goal: Batteries.AssocList.findEntry? a l = List.find? (fun x => x.fst == a) l.toList
-- Batteries.AssocList.find?_eq_findEntry?
theorem find?_eq_findEntry? [BEq α] (a : α) (l : AssocList α β) :
    find? a l = (l.findEntry? a).map (·.2) 
Arguments: {α : Type u_1} {β : Type u_2} [BEq α] (a : α) (l : Batteries.AssocList α β)
Goal: Batteries.AssocList.find? a l = Option.map (fun x => x.snd) (Batteries.AssocList.findEntry? a l)
-- Batteries.AssocList.find?_eq
@[simp] theorem find?_eq [BEq α] (a : α) (l : AssocList α β) :
    find? a l = (l.toList.find? (·.1 == a)).map (·.2) 
Arguments: {α : Type u_1} {β : Type u_2} [BEq α] (a : α) (l : Batteries.AssocList α β)
Goal: Batteries.AssocList.find? a l = Option.map (fun x => x.snd) (List.find? (fun x => x.fst == a) l.toList)
-- Batteries.AssocList.any_eq
@[simp] theorem any_eq (p : α → β → Bool) (l : AssocList α β) :
    any p l = l.toList.any fun (a, b) => p a b 
Arguments: {α : Type u_1} {β : Type u_2} (p : α → β → Bool) (l : Batteries.AssocList α β)
Goal: Batteries.AssocList.any p l =
  l.toList.any fun x =>
    match x with
    | (a, b) => p a b
-- Batteries.AssocList.all_eq
@[simp] theorem all_eq (p : α → β → Bool) (l : AssocList α β) :
    all p l = l.toList.all fun (a, b) => p a b 
Arguments: {α : Type u_1} {β : Type u_2} (p : α → β → Bool) (l : Batteries.AssocList α β)
Goal: Batteries.AssocList.all p l =
  l.toList.all fun x =>
    match x with
    | (a, b) => p a b
-- Batteries.AssocList.contains_eq
@[simp] theorem contains_eq [BEq α] (a : α) (l : AssocList α β) :
    contains a l = l.toList.any (·.1 == a) 
Arguments: {α : Type u_1} {β : Type u_2} [BEq α] (a : α) (l : Batteries.AssocList α β)
Goal: Batteries.AssocList.contains a l = l.toList.any fun x => x.fst == a
-- Batteries.AssocList.toList_replace
@[simp] theorem toList_replace [BEq α] (a : α) (b : β) (l : AssocList α β) :
    (replace a b l).toList =
    l.toList.replaceF (bif ·.1 == a then some (a, b) else none) 
Arguments: {α : Type u_1} {β : Type u_2} [BEq α] (a : α) (b : β) (l : Batteries.AssocList α β)
Goal: (Batteries.AssocList.replace a b l).toList = List.replaceF (fun x => bif x.fst == a then some (a, b) else none) l.toList
-- Batteries.AssocList.length_replace
@[simp] theorem length_replace [BEq α] {a : α} : (replace a b l).length = l.length 
Arguments: {α : Type u_1}
Goal: ∀ {β : Type u_2} {b : β} {l : Batteries.AssocList α β} [inst : BEq α] {a : α},
  (Batteries.AssocList.replace a b l).length = l.length
-- Batteries.AssocList.toList_eraseP
@[simp] theorem toList_eraseP (p) (l : AssocList α β) :
    (eraseP p l).toList = l.toList.eraseP fun (a, b) => p a b 
Arguments: {α : Type u_1} {β : Type u_2} (p : α → β → Bool) (l : Batteries.AssocList α β)
Goal: (Batteries.AssocList.eraseP p l).toList =
  List.eraseP
    (fun x =>
      match x with
      | (a, b) => p a b)
    l.toList
-- Batteries.AssocList.toList_erase
@[simp] theorem toList_erase [BEq α] (a : α) (l : AssocList α β) :
    (erase a l).toList = l.toList.eraseP (·.1 == a) 
Arguments: {α : Type u_1} {β : Type u_2} [BEq α] (a : α) (l : Batteries.AssocList α β)
Goal: (Batteries.AssocList.erase a l).toList = List.eraseP (fun x => x.fst == a) l.toList
-- Batteries.AssocList.toList_modify
@[simp] theorem toList_modify [BEq α] (a : α) (l : AssocList α β) :
    (modify a f l).toList =
    l.toList.replaceF fun (k, v) => bif k == a then some (a, f k v) else none 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β → β} [BEq α] (a : α) (l : Batteries.AssocList α β)
Goal: (Batteries.AssocList.modify a f l).toList =
  List.replaceF
    (fun x =>
      match x with
      | (k, v) => bif k == a then some (a, f k v) else none)
    l.toList
-- Batteries.AssocList.length_modify
@[simp] theorem length_modify [BEq α] {a : α} : (modify a f l).length = l.length 
Arguments: {α : Type u_1}
Goal: ∀ {β : Type u_2} {f : α → β → β} {l : Batteries.AssocList α β} [inst : BEq α] {a : α},
  (Batteries.AssocList.modify a f l).length = l.length
-- Batteries.AssocList.forIn_eq
@[simp] theorem forIn_eq [Monad m] (l : AssocList α β) (init : δ)
    (f : (α × β) → δ → m (ForInStep δ)) : forIn l init f = forIn l.toList init f 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_4} {δ : Type u_1} [Monad m] (l : Batteries.AssocList α β) (init : δ) (f : α × β → δ → m (ForInStep δ))
Goal: forIn l init f = forIn l.toList init f
-- List.toList_toAssocList
@[simp] theorem _root_.List.toList_toAssocList (l : List (α × β)) : l.toAssocList.toList = l 
Arguments: {α : Type u_1} {β : Type u_2} (l : List (α × β))
Goal: l.toAssocList.toList = l
-- Batteries.AssocList.toList_toAssocList
@[simp] theorem toList_toAssocList (l : AssocList α β) : l.toList.toAssocList = l 
Arguments: {α : Type u_1} {β : Type u_2} (l : Batteries.AssocList α β)
Goal: l.toList.toAssocList = l
-- List.length_toAssocList
@[simp] theorem _root_.List.length_toAssocList (l : List (α × β)) :
    l.toAssocList.length = l.length 
Arguments: {α : Type u_1} {β : Type u_2} (l : List (α × β))
Goal: l.toAssocList.length = l.length
-- Batteries.AssocList.beq_nil₂
@[simp] theorem beq_nil₂ [BEq α] [BEq β] : ((.nil : AssocList α β) == .nil) = true 
Arguments: {α : Type u_1} {β : Type u_2} [BEq α] [BEq β]
Goal: (Batteries.AssocList.nil == Batteries.AssocList.nil) = true
-- Batteries.AssocList.beq_nil_cons
@[simp] theorem beq_nil_cons [BEq α] [BEq β] : ((.nil : AssocList α β) == .cons a b t) = false 
Arguments: {α : Type u_1} {β : Type u_2} {a : α} {b : β} {t : Batteries.AssocList α β} [BEq α] [BEq β]
Goal: (Batteries.AssocList.nil == Batteries.AssocList.cons a b t) = false
-- Batteries.AssocList.beq_cons_nil
@[simp] theorem beq_cons_nil [BEq α] [BEq β] : ((.cons a b t : AssocList α β) == .nil) = false 
Arguments: {α : Type u_1} {β : Type u_2} {a : α} {b : β} {t : Batteries.AssocList α β} [BEq α] [BEq β]
Goal: (Batteries.AssocList.cons a b t == Batteries.AssocList.nil) = false
-- Batteries.AssocList.beq_cons₂
@[simp] theorem beq_cons₂ [BEq α] [BEq β] :
    ((.cons a b t : AssocList α β) == .cons a' b' t') = (a == a' && b == b' && t == t') 
Arguments: {α : Type u_1} {β : Type u_2} {a : α} {b : β} {t : Batteries.AssocList α β} {a' : α} {b' : β} {t' : Batteries.AssocList α β} [BEq α] [BEq β]
Goal: (Batteries.AssocList.cons a b t == Batteries.AssocList.cons a' b' t') = (a == a' && b == b' && t == t')
-- Batteries.AssocList.beq_eq
protected theorem beq_eq [BEq α] [BEq β] {l m : AssocList α β} :
    (l == m) = (l.toList == m.toList) 
Arguments: {α : Type u_1} {β : Type u_2} [BEq α] [BEq β] {l m : Batteries.AssocList α β}
Goal: (l == m) = (l.toList == m.toList)
-- Rat.den_nz
-- `Rat` is not tagged with the `ext` attribute, since this is more often than not undesirable
structure Rat where
    mk' ::
    num : Int
    den : Nat := 1
    den_nz : den ≠ 0 := by decide
    reduced : num.natAbs.Coprime den := by decide
  deriving DecidableEq
Arguments: (self : Rat)
Goal: self.den ≠ 0
-- Rat.reduced
-- `Rat` is not tagged with the `ext` attribute, since this is more often than not undesirable
structure Rat where
    mk' ::
    num : Int
    den : Nat := 1
    den_nz : den ≠ 0 := by decide
    reduced : num.natAbs.Coprime den := by decide
  deriving DecidableEq
Arguments: (self : Rat)
Goal: self.num.natAbs.Coprime self.den
-- Rat.den_pos
theorem Rat.den_pos (self : Rat) : 0 < self.den 
Arguments: (self : Rat)
Goal: 0 < self.den
-- Rat.normalize.den_nz
theorem Rat.normalize.den_nz {num : Int} {den g : Nat} (den_nz : den ≠ 0)
    (e : g = num.natAbs.gcd den) : den / g ≠ 0 
Arguments: {num : Int} {den g : Nat} (den_nz : den ≠ 0) (e : g = num.natAbs.gcd den)
Goal: den / g ≠ 0
-- Rat.normalize.reduced
theorem Rat.normalize.reduced {num : Int} {den g : Nat} (den_nz : den ≠ 0)
    (e : g = num.natAbs.gcd den) : (num.div g).natAbs.Coprime (den / g) 
Arguments: {num : Int} {den g : Nat} (den_nz : den ≠ 0) (e : g = num.natAbs.gcd den)
Goal: (num.div ↑g).natAbs.Coprime (den / g)
-- Rat.add.aux
theorem add.aux (a b : Rat) {g ad bd} (hg : g = a.den.gcd b.den)
    (had : ad = a.den / g) (hbd : bd = b.den / g) :
    let den := ad * b.den; let num := a.num * bd + b.num * ad
    num.natAbs.gcd g = num.natAbs.gcd den 
Arguments: (a b : Rat) {g ad bd : Nat} (hg : g = a.den.gcd b.den) (had : ad = a.den / g) (hbd : bd = b.den / g)
Goal: let den := ad * b.den;
let num := a.num * ↑bd + b.num * ↑ad;
num.natAbs.gcd g = num.natAbs.gcd den
-- Rat.sub.aux
theorem sub.aux (a b : Rat) {g ad bd} (hg : g = a.den.gcd b.den)
    (had : ad = a.den / g) (hbd : bd = b.den / g) :
    let den := ad * b.den; let num := a.num * bd - b.num * ad
    num.natAbs.gcd g = num.natAbs.gcd den 
Arguments: (a b : Rat) {g ad bd : Nat} (hg : g = a.den.gcd b.den) (had : ad = a.den / g) (hbd : bd = b.den / g)
Goal: let den := ad * b.den;
let num := a.num * ↑bd - b.num * ↑ad;
num.natAbs.gcd g = num.natAbs.gcd den
-- Array.forIn_eq_data_forIn.loop
theorem forIn_eq_data_forIn [Monad m]
    (as : Array α) (b : β) (f : α → β → m (ForInStep β)) :
    forIn as b f = forIn as.data b f 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] (as : Array α) (f : α → β → m (ForInStep β)) {i : Nat} {h : i ≤ as.size} {b : β} {j : Nat}
Goal: j + i = as.size → Array.forIn.loop as f i h b = forIn (List.drop j as.data) b f
-- Array.forIn_eq_data_forIn
theorem forIn_eq_data_forIn [Monad m]
    (as : Array α) (b : β) (f : α → β → m (ForInStep β)) :
    forIn as b f = forIn as.data b f 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] (as : Array α) (b : β) (f : α → β → m (ForInStep β))
Goal: forIn as b f = forIn as.data b f
-- Array.zipWith_eq_zipWith_data.loop
theorem zipWith_eq_zipWith_data (f : α → β → γ) (as : Array α) (bs : Array β) :
    (as.zipWith bs f).data = as.data.zipWith f bs.data 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) (as : Array α) (bs : Array β) (i : Nat) (cs : Array γ)
Goal: i ≤ as.size →
  i ≤ bs.size →
    (Array.zipWithAux f as bs i cs).data = cs.data ++ List.zipWith f (List.drop i as.data) (List.drop i bs.data)
-- Array.zipWith_eq_zipWith_data
theorem zipWith_eq_zipWith_data (f : α → β → γ) (as : Array α) (bs : Array β) :
    (as.zipWith bs f).data = as.data.zipWith f bs.data 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) (as : Array α) (bs : Array β)
Goal: (as.zipWith bs f).data = List.zipWith f as.data bs.data
-- Array.size_zipWith
theorem size_zipWith (as : Array α) (bs : Array β) (f : α → β → γ) :
    (as.zipWith bs f).size = min as.size bs.size 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (as : Array α) (bs : Array β) (f : α → β → γ)
Goal: (as.zipWith bs f).size = min as.size bs.size
-- Array.zip_eq_zip_data
theorem zip_eq_zip_data (as : Array α) (bs : Array β) :
    (as.zip bs).data = as.data.zip bs.data 
Arguments: {α : Type u_1} {β : Type u_2} (as : Array α) (bs : Array β)
Goal: (as.zip bs).data = as.data.zip bs.data
-- Array.size_zip
theorem size_zip (as : Array α) (bs : Array β) :
    (as.zip bs).size = min as.size bs.size 
Arguments: {α : Type u_1} {β : Type u_2} (as : Array α) (bs : Array β)
Goal: (as.zip bs).size = min as.size bs.size
-- Array.size_filter_le
theorem size_filter_le (p : α → Bool) (l : Array α) :
    (l.filter p).size ≤ l.size 
Arguments: {α : Type u_1} (p : α → Bool) (l : Array α)
Goal: (Array.filter p l 0).size ≤ l.size
-- Array.join_data
@[simp] theorem join_data {l : Array (Array α)} : l.join.data = (l.data.map data).join 
Arguments: {α : Type u_1} {l : Array (Array α)}
Goal: l.join.data = (List.map Array.data l.data).join
-- Array.mem_join
theorem mem_join : ∀ {L : Array (Array α)}, a ∈ L.join ↔ ∃ l, l ∈ L ∧ a ∈ l 
Arguments: {α : Type u_1} {a : α} {L : Array (Array α)}
Goal: a ∈ L.join ↔ ∃ l, l ∈ L ∧ a ∈ l
-- Array.size_shrink_loop
theorem size_shrink_loop (a : Array α) (n) : (shrink.loop n a).size = a.size - n 
Arguments: {α : Type u_1} (a : Array α) (n : Nat)
Goal: (Array.shrink.loop n a).size = a.size - n
-- Array.size_shrink
theorem size_shrink (a : Array α) (n) : (a.shrink n).size = min a.size n 
Arguments: {α : Type u_1} (a : Array α) (n : Nat)
Goal: (a.shrink n).size = min a.size n
-- Array.mapM_empty
theorem mapM_empty [Monad m] (f : α → m β) : mapM f #[] = pure #[] 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] (f : α → m β)
Goal: Array.mapM f #[] = pure #[]
-- Array.map_empty
@[simp] theorem map_empty (f : α → β) : map f #[] = #[] 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β)
Goal: Array.map f #[] = #[]
-- Array.mem_singleton
theorem mem_singleton : a ∈ #[b] ↔ a = b 
Goal: ∀ {α : Type u_1} {a b : α}, a ∈ #[b] ↔ a = b
-- LazyList.append_nil
theorem append_nil {α} (xs : LazyList α) : xs.append (Thunk.pure LazyList.nil) = xs 
Arguments: {α : Type u_1} (xs : LazyList α)
Goal: xs.append (Thunk.pure LazyList.nil) = xs
-- LazyList.append_assoc
theorem append_assoc {α} (xs ys zs : LazyList α) :
    (xs.append ys).append zs = xs.append (ys.append zs) 
Arguments: {α : Type u_1} (xs ys zs : LazyList α)
Goal: (xs.append { fn := fun x => ys }).append { fn := fun x => zs } =
  xs.append { fn := fun x => ys.append { fn := fun x => zs } }
-- LazyList.append_bind
theorem append_bind {α β} (xs : LazyList α) (ys : Thunk (LazyList α)) (f : α → LazyList β) :
    (xs.append ys).bind f = (xs.bind f).append (ys.get.bind f) 
Arguments: {α : Type u_1} {β : Type u_2} (xs : LazyList α) (ys : Thunk (LazyList α)) (f : α → LazyList β)
Goal: (xs.append ys).bind f = (xs.bind f).append { fn := fun x => ys.get.bind f }
-- LazyList.mem_nil
@[simp]
theorem mem_nil {α} (x : α) : x ∈ @LazyList.nil α ↔ False 
Arguments: {α : Type u_1} (x : α)
Goal: x ∈ LazyList.nil ↔ False
-- LazyList.mem_cons
@[simp]
theorem mem_cons {α} (x y : α) (ys : Thunk (LazyList α)) :
    x ∈ @LazyList.cons α y ys ↔ x = y ∨ x ∈ ys.get 
Arguments: {α : Type u_1} (x y : α) (ys : Thunk (LazyList α))
Goal: x ∈ LazyList.cons y ys ↔ x = y ∨ x ∈ ys.get
-- LazyList.forall_mem_cons
theorem forall_mem_cons {α} {p : α → Prop} {a : α} {l : Thunk (LazyList α)} :
    (∀ x ∈ @LazyList.cons _ a l, p x) ↔ p a ∧ ∀ x ∈ l.get, p x 
Arguments: {α : Type u_1} {p : α → Prop} {a : α} {l : Thunk (LazyList α)}
Goal: (∀ (x : α), x ∈ LazyList.cons a l → p x) ↔ p a ∧ ∀ (x : α), x ∈ l.get → p x
-- Set.ext
theorem ext {a b : Set α} (h : ∀ (x : α), x ∈ a ↔ x ∈ b) : a = b 
Arguments: {α : Type u_1} {a b : Set α} (h : ∀ (x : α), x ∈ a ↔ x ∈ b)
Goal: a = b
-- Array.SatisfiesM_foldlM.go
theorem SatisfiesM_foldlM [Monad m] [LawfulMonad m]
    {as : Array α} (motive : Nat → β → Prop) {init : β} (h0 : motive 0 init) {f : β → α → m β}
    (hf : ∀ i : Fin as.size, ∀ b, motive i.1 b → SatisfiesM (motive (i.1 + 1)) (f b as[i])) :
    SatisfiesM (motive as.size) (as.foldlM f init) 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] [LawfulMonad m] {as : Array α} (motive : Nat → β → Prop) {f : β → α → m β} (hf : ∀ (i : Fin as.size) (b : β), motive (↑i) b → SatisfiesM (motive (↑i + 1)) (f b as[i])) {i j : Nat} {b : β} (h₁ : j ≤ as.size) (h₂ : as.size ≤ i + j) (H : motive j b)
Goal: SatisfiesM (motive as.size) (Array.foldlM.loop f as as.size ⋯ i j b)
-- Array.SatisfiesM_foldlM
theorem SatisfiesM_foldlM [Monad m] [LawfulMonad m]
    {as : Array α} (motive : Nat → β → Prop) {init : β} (h0 : motive 0 init) {f : β → α → m β}
    (hf : ∀ i : Fin as.size, ∀ b, motive i.1 b → SatisfiesM (motive (i.1 + 1)) (f b as[i])) :
    SatisfiesM (motive as.size) (as.foldlM f init) 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] [LawfulMonad m] {as : Array α} (motive : Nat → β → Prop) {init : β} (h0 : motive 0 init) {f : β → α → m β} (hf : ∀ (i : Fin as.size) (b : β), motive (↑i) b → SatisfiesM (motive (↑i + 1)) (f b as[i]))
Goal: SatisfiesM (motive as.size) (Array.foldlM f init as 0)
-- Array.SatisfiesM_mapM
theorem SatisfiesM_mapM [Monad m] [LawfulMonad m] (as : Array α) (f : α → m β)
    (motive : Nat → Prop) (h0 : motive 0)
    (p : Fin as.size → β → Prop)
    (hs : ∀ i, motive i.1 → SatisfiesM (p i · ∧ motive (i + 1)) (f as[i])) :
    SatisfiesM
      (fun arr => motive as.size ∧ ∃ eq : arr.size = as.size, ∀ i h, p ⟨i, h⟩ arr[i])
      (Array.mapM f as) 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] [LawfulMonad m] (as : Array α) (f : α → m β) (motive : Nat → Prop) (h0 : motive 0) (p : Fin as.size → β → Prop) (hs : ∀ (i : Fin as.size), motive ↑i → SatisfiesM (fun x => p i x ∧ motive (↑i + 1)) (f as[i]))
Goal: SatisfiesM (fun arr => motive as.size ∧ ∃ eq, ∀ (i : Nat) (h : i < as.size), p ⟨i, h⟩ arr[i]) (Array.mapM f as)
-- Array.SatisfiesM_mapM'
theorem SatisfiesM_mapM' [Monad m] [LawfulMonad m] (as : Array α) (f : α → m β)
    (p : Fin as.size → β → Prop)
    (hs : ∀ i, SatisfiesM (p i) (f as[i])) :
    SatisfiesM
      (fun arr => ∃ eq : arr.size = as.size, ∀ i h, p ⟨i, h⟩ arr[i])
      (Array.mapM f as) 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] [LawfulMonad m] (as : Array α) (f : α → m β) (p : Fin as.size → β → Prop) (hs : ∀ (i : Fin as.size), SatisfiesM (p i) (f as[i]))
Goal: SatisfiesM (fun arr => ∃ eq, ∀ (i : Nat) (h : i < as.size), p ⟨i, h⟩ arr[i]) (Array.mapM f as)
-- Array.size_mapM
theorem size_mapM [Monad m] [LawfulMonad m] (f : α → m β) (as : Array α) :
    SatisfiesM (fun arr => arr.size = as.size) (Array.mapM f as) 
Arguments: {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] [LawfulMonad m] (f : α → m β) (as : Array α)
Goal: SatisfiesM (fun arr => arr.size = as.size) (Array.mapM f as)
-- Array.SatisfiesM_anyM.go
theorem SatisfiesM_anyM [Monad m] [LawfulMonad m] (p : α → m Bool) (as : Array α) (start stop)
    (hstart : start ≤ min stop as.size) (tru : Prop) (fal : Nat → Prop) (h0 : fal start)
    (hp : ∀ i : Fin as.size, i.1 < stop → fal i.1 →
      SatisfiesM (bif · then tru else fal (i + 1)) (p as[i])) :
    SatisfiesM
      (fun res => bif res then tru else fal (min stop as.size))
      (anyM p as start stop) 
Arguments: {m : Type → Type u_1} {α : Type u_2} [Monad m] [LawfulMonad m] (p : α → m Bool) (as : Array α) (tru : Prop) (fal : Nat → Prop) {stop j : Nat} (hj' : j ≤ stop) (hstop : stop ≤ as.size) (h0 : fal j) (hp : ∀ (i : Fin as.size), ↑i < stop → fal ↑i → SatisfiesM (fun x => bif x then tru else fal (↑i + 1)) (p as[i]))
Goal: SatisfiesM (fun res => bif res then tru else fal stop) (Array.anyM.loop p as stop hstop j)
-- Array.SatisfiesM_anyM
theorem SatisfiesM_anyM [Monad m] [LawfulMonad m] (p : α → m Bool) (as : Array α) (start stop)
    (hstart : start ≤ min stop as.size) (tru : Prop) (fal : Nat → Prop) (h0 : fal start)
    (hp : ∀ i : Fin as.size, i.1 < stop → fal i.1 →
      SatisfiesM (bif · then tru else fal (i + 1)) (p as[i])) :
    SatisfiesM
      (fun res => bif res then tru else fal (min stop as.size))
      (anyM p as start stop) 
Arguments: {m : Type → Type u_1} {α : Type u_2} [Monad m] [LawfulMonad m] (p : α → m Bool) (as : Array α) (start stop : Nat) (hstart : start ≤ min stop as.size) (tru : Prop) (fal : Nat → Prop) (h0 : fal start) (hp : ∀ (i : Fin as.size), ↑i < stop → fal ↑i → SatisfiesM (fun x => bif x then tru else fal (↑i + 1)) (p as[i]))
Goal: SatisfiesM (fun res => bif res then tru else fal (min stop as.size)) (Array.anyM p as start stop)