ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- dite_some_none_eq_none
theorem dite_some_none_eq_none [Decidable P] {x : P → α} :
    (if h : P then some (x h) else none) = none ↔ ¬P 
Arguments: {P : Prop} {α : Type u_1} [Decidable P] {x : P → α}
Goal: (if h : P then some (x h) else none) = none ↔ ¬P
-- dite_some_none_eq_some
@[simp] theorem dite_some_none_eq_some [Decidable P] {x : P → α} {y : α} :
    (if h : P then some (x h) else none) = some y ↔ ∃ h : P, x h = y 
Arguments: {P : Prop} {α : Type u_1} [Decidable P] {x : P → α} {y : α}
Goal: (if h : P then some (x h) else none) = some y ↔ ∃ h, x h = y
-- Batteries.HashMap.Imp.Buckets.ext
@[ext] protected theorem ext : ∀ {b₁ b₂ : Buckets α β}, b₁.1.data = b₂.1.data → b₁ = b₂
  
Arguments: {α : Type u_1} {β : Type u_2} {b₁ b₂ : Batteries.HashMap.Imp.Buckets α β}
Goal: b₁.val.data = b₂.val.data → b₁ = b₂
-- Batteries.HashMap.Imp.Buckets.update_data
theorem update_data (self : Buckets α β) (i d h) :
    (self.update i d h).1.data = self.1.data.set i.toNat d 
Arguments: {α : Type u_1} {β : Type u_2} (self : Batteries.HashMap.Imp.Buckets α β) (i : USize) (d : Batteries.AssocList α β) (h : i.toNat < self.val.size)
Goal: (self.update i d h).val.data = self.val.data.set i.toNat d
-- Batteries.HashMap.Imp.Buckets.exists_of_update
theorem exists_of_update (self : Buckets α β) (i d h) :
    ∃ l₁ l₂, self.1.data = l₁ ++ self.1[i] :: l₂ ∧ List.length l₁ = i.toNat ∧
      (self.update i d h).1.data = l₁ ++ d :: l₂ 
Arguments: {α : Type u_1} {β : Type u_2} (self : Batteries.HashMap.Imp.Buckets α β) (i : USize) (d : Batteries.AssocList α β) (h : i.toNat < self.val.size)
Goal: ∃ l₁ l₂, self.val.data = l₁ ++ self.val[i] :: l₂ ∧ l₁.length = i.toNat ∧ (self.update i d h).val.data = l₁ ++ d :: l₂
-- Batteries.HashMap.Imp.Buckets.update_update
theorem update_update (self : Buckets α β) (i d d' h h') :
    (self.update i d h).update i d' h' = self.update i d' h 
Arguments: {α : Type u_1} {β : Type u_2} (self : Batteries.HashMap.Imp.Buckets α β) (i : USize) (d d' : Batteries.AssocList α β) (h : i.toNat < self.val.size) (h' : i.toNat < (self.update i d h).val.size)
Goal: (self.update i d h).update i d' h' = self.update i d' h
-- Batteries.HashMap.Imp.Buckets.size_eq
theorem size_eq (data : Buckets α β) :
  size data = .sum (data.1.data.map (·.toList.length)) 
Arguments: {α : Type u_1} {β : Type u_2} (data : Batteries.HashMap.Imp.Buckets α β)
Goal: data.size = Nat.sum (List.map (fun x => x.toList.length) data.val.data)
-- Batteries.HashMap.Imp.Buckets.mk_size
theorem mk_size (h) : (mk n h : Buckets α β).size = 0 
Arguments: {α : Type u_1} {β : Type u_2} {n : Nat} (h : 0 < n)
Goal: (Batteries.HashMap.Imp.Buckets.mk n h).size = 0
-- Batteries.HashMap.Imp.Buckets.WF.mk'
theorem WF.mk' [BEq α] [Hashable α] (h) : (Buckets.mk n h : Buckets α β).WF 
Arguments: {α : Type u_1} {β : Type u_2} {n : Nat} [BEq α] [Hashable α] (h : 0 < n)
Goal: (Batteries.HashMap.Imp.Buckets.mk n h).WF
-- Batteries.HashMap.Imp.Buckets.WF.update
theorem WF.update [BEq α] [Hashable α] {buckets : Buckets α β} {i d h} (H : buckets.WF)
    (h₁ : ∀ [PartialEquivBEq α] [LawfulHashable α],
      (buckets.1[i].toList.Pairwise fun a b => ¬(a.1 == b.1)) →
      d.toList.Pairwise fun a b => ¬(a.1 == b.1))
    (h₂ : (buckets.1[i].All fun k _ => ((hash k).toUSize % buckets.1.size).toNat = i.toNat) →
      d.All fun k _ => ((hash k).toUSize % buckets.1.size).toNat = i.toNat) :
    (buckets.update i d h).WF 
Arguments: {α : Type u_1} {β : Type u_2} [BEq α] [Hashable α] {buckets : Batteries.HashMap.Imp.Buckets α β} {i : USize} {d : Batteries.AssocList α β} {h : i.toNat < buckets.val.size} (H : buckets.WF) (h₁ :
  ∀ [inst : PartialEquivBEq α] [inst : Batteries.HashMap.LawfulHashable α],
    List.Pairwise (fun a b => ¬(a.fst == b.fst) = true) buckets.val[i].toList →
      List.Pairwise (fun a b => ¬(a.fst == b.fst) = true) d.toList) (h₂ :
  Batteries.AssocList.All (fun k x => ((hash k).toUSize % buckets.val.size).toNat = i.toNat) buckets.val[i] →
    Batteries.AssocList.All (fun k x => ((hash k).toUSize % buckets.val.size).toNat = i.toNat) d)
Goal: (buckets.update i d h).WF
-- Batteries.HashMap.Imp.reinsertAux_size
theorem reinsertAux_size [Hashable α] (data : Buckets α β) (a : α) (b : β) :
    (reinsertAux data a b).size = data.size.succ 
Arguments: {α : Type u_1} {β : Type u_2} [Hashable α] (data : Batteries.HashMap.Imp.Buckets α β) (a : α) (b : β)
Goal: (Batteries.HashMap.Imp.reinsertAux data a b).size = data.size.succ
-- Batteries.HashMap.Imp.reinsertAux_WF
theorem reinsertAux_WF [BEq α] [Hashable α] {data : Buckets α β} {a : α} {b : β} (H : data.WF)
    (h₁ : ∀ [PartialEquivBEq α] [LawfulHashable α],
      haveI := mkIdx data.2 (hash a).toUSize
      data.val[this.1].All fun x _ => ¬(a == x)) :
    (reinsertAux data a b).WF 
Arguments: {α : Type u_1} {β : Type u_2} [BEq α] [Hashable α] {data : Batteries.HashMap.Imp.Buckets α β} {a : α} {b : β} (H : data.WF) (h₁ :
  ∀ [inst : PartialEquivBEq α] [inst : Batteries.HashMap.LawfulHashable α],
    Batteries.AssocList.All (fun x x_1 => ¬(a == x) = true)
      data.val[(Batteries.HashMap.Imp.mkIdx ⋯ (hash a).toUSize).val])
Goal: (Batteries.HashMap.Imp.reinsertAux data a b).WF
-- Batteries.HashMap.Imp.expand_size
theorem expand_size [Hashable α] {buckets : Buckets α β} :
    (expand sz buckets).buckets.size = buckets.size 
Arguments: {α : Type u_1} {β : Type u_2} {sz : Nat} [Hashable α] {buckets : Batteries.HashMap.Imp.Buckets α β}
Goal: (Batteries.HashMap.Imp.expand sz buckets).buckets.size = buckets.size
-- Batteries.HashMap.Imp.expand_size.go
theorem expand_size [Hashable α] {buckets : Buckets α β} :
    (expand sz buckets).buckets.size = buckets.size 
Arguments: {α : Type u_1} {β : Type u_2} [Hashable α] (i : Nat) (source : Array (Batteries.AssocList α β)) (target : Batteries.HashMap.Imp.Buckets α β) (hs : ∀ (j : Nat), j < i → source.data[j]?.getD Batteries.AssocList.nil = Batteries.AssocList.nil)
Goal: (Batteries.HashMap.Imp.expand.go i source target).size =
  Nat.sum (List.map (fun x => x.toList.length) source.data) + target.size
-- Batteries.HashMap.Imp.expand_WF.foldl
theorem expand_WF.foldl [BEq α] [Hashable α] (rank : α → Nat) {l : List (α × β)} {i : Nat}
    (hl₁ : ∀ [PartialEquivBEq α] [LawfulHashable α], l.Pairwise fun a b => ¬(a.1 == b.1))
    (hl₂ : ∀ x ∈ l, rank x.1 = i)
    {target : Buckets α β} (ht₁ : target.WF)
    (ht₂ : ∀ bucket ∈ target.1.data,
      bucket.All fun k _ => rank k ≤ i ∧
        ∀ [PartialEquivBEq α] [LawfulHashable α], ∀ x ∈ l, ¬(x.1 == k)) :
    (l.foldl (fun d x => reinsertAux d x.1 x.2) target).WF ∧
    ∀ bucket ∈ (l.foldl (fun d x => reinsertAux d x.1 x.2) target).1.data,
      bucket.All fun k _ => rank k ≤ i 
Arguments: {α : Type u_1} {β : Type u_2} [BEq α] [Hashable α] (rank : α → Nat) {l : List (α × β)} {i : Nat} (hl₁ :
  ∀ [inst : PartialEquivBEq α] [inst : Batteries.HashMap.LawfulHashable α],
    List.Pairwise (fun a b => ¬(a.fst == b.fst) = true) l) (hl₂ : ∀ (x : α × β), x ∈ l → rank x.fst = i) {target : Batteries.HashMap.Imp.Buckets α β} (ht₁ : target.WF) (ht₂ :
  ∀ (bucket : Batteries.AssocList α β),
    bucket ∈ target.val.data →
      Batteries.AssocList.All
        (fun k x =>
          rank k ≤ i ∧
            ∀ [inst : PartialEquivBEq α] [inst : Batteries.HashMap.LawfulHashable α] (x : α × β),
              x ∈ l → ¬(x.fst == k) = true)
        bucket)
Goal: (List.foldl (fun d x => Batteries.HashMap.Imp.reinsertAux d x.fst x.snd) target l).WF ∧
  ∀ (bucket : Batteries.AssocList α β),
    bucket ∈ (List.foldl (fun d x => Batteries.HashMap.Imp.reinsertAux d x.fst x.snd) target l).val.data →
      Batteries.AssocList.All (fun k x => rank k ≤ i) bucket
-- Batteries.HashMap.Imp.expand_WF.go
theorem expand_WF [BEq α] [Hashable α] {buckets : Buckets α β} (H : buckets.WF) :
    (expand sz buckets).buckets.WF 
Arguments: {α : Type u_1} {β : Type u_2} [BEq α] [Hashable α] (i : Nat) {source : Array (Batteries.AssocList α β)} (hs₁ :
  ∀ [inst : Batteries.HashMap.LawfulHashable α] [inst : PartialEquivBEq α] (bucket : Batteries.AssocList α β),
    bucket ∈ source.data → List.Pairwise (fun a b => ¬(a.fst == b.fst) = true) bucket.toList) (hs₂ :
  ∀ (j : Nat) (h : j < source.size),
    Batteries.AssocList.All (fun k x => ((hash k).toUSize % source.size).toNat = j) source[j]) {target : Batteries.HashMap.Imp.Buckets α β} (ht :
  target.WF ∧
    ∀ (bucket : Batteries.AssocList α β),
      bucket ∈ target.val.data → Batteries.AssocList.All (fun k x => ((hash k).toUSize % source.size).toNat < i) bucket)
Goal: (Batteries.HashMap.Imp.expand.go i source target).WF
-- Batteries.HashMap.Imp.expand_WF
theorem expand_WF [BEq α] [Hashable α] {buckets : Buckets α β} (H : buckets.WF) :
    (expand sz buckets).buckets.WF 
Arguments: {α : Type u_1} {β : Type u_2} {sz : Nat} [BEq α] [Hashable α] {buckets : Batteries.HashMap.Imp.Buckets α β} (H : buckets.WF)
Goal: (Batteries.HashMap.Imp.expand sz buckets).buckets.WF
-- Batteries.HashMap.Imp.insert_size
theorem insert_size [BEq α] [Hashable α] {m : Imp α β} {k v}
    (h : m.size = m.buckets.size) :
    (insert m k v).size = (insert m k v).buckets.size 
Arguments: {α : Type u_1} {β : Type u_2} [BEq α] [Hashable α] {m : Batteries.HashMap.Imp α β} {k : α} {v : β} (h : m.size = m.buckets.size)
Goal: (m.insert k v).size = (m.insert k v).buckets.size
-- _private.«.lake».packages.batteries.Batteries.Data.HashMap.WF.0.Batteries.HashMap.Imp.mem_replaceF
private theorem mem_replaceF {l : List (α × β)} {x : α × β} {p : α × β → Bool} {f : α × β → β} :
    x ∈ (l.replaceF fun a => bif p a then some (k, f a) else none) → x.1 = k ∨ x ∈ l 
Arguments: {α : Type u_1} {β : Type u_2} {k : α} {l : List (α × β)} {x : α × β} {p : α × β → Bool} {f : α × β → β}
Goal: x ∈ List.replaceF (fun a => bif p a then some (k, f a) else none) l → x.fst = k ∨ x ∈ l
-- _private.«.lake».packages.batteries.Batteries.Data.HashMap.WF.0.Batteries.HashMap.Imp.pairwise_replaceF
private theorem pairwise_replaceF [BEq α] [PartialEquivBEq α]
    {l : List (α × β)} {f : α × β → β}
    (H : l.Pairwise fun a b => ¬(a.fst == b.fst)) :
    (l.replaceF fun a => bif a.fst == k then some (k, f a) else none)
      |>.Pairwise fun a b => ¬(a.fst == b.fst) 
Arguments: {α : Type u_1} {β : Type u_2} {k : α} [BEq α] [PartialEquivBEq α] {l : List (α × β)} {f : α × β → β} (H : List.Pairwise (fun a b => ¬(a.fst == b.fst) = true) l)
Goal: List.Pairwise (fun a b => ¬(a.fst == b.fst) = true)
  (List.replaceF (fun a => bif a.fst == k then some (k, f a) else none) l)
-- Batteries.HashMap.Imp.insert_WF
theorem insert_WF [BEq α] [Hashable α] {m : Imp α β} {k v}
    (h : m.buckets.WF) : (insert m k v).buckets.WF 
Arguments: {α : Type u_1} {β : Type u_2} [BEq α] [Hashable α] {m : Batteries.HashMap.Imp α β} {k : α} {v : β} (h : m.buckets.WF)
Goal: (m.insert k v).buckets.WF
-- Batteries.HashMap.Imp.erase_size
theorem erase_size [BEq α] [Hashable α] {m : Imp α β} {k}
    (h : m.size = m.buckets.size) :
    (erase m k).size = (erase m k).buckets.size 
Arguments: {α : Type u_1} {β : Type u_2} [BEq α] [Hashable α] {m : Batteries.HashMap.Imp α β} {k : α} (h : m.size = m.buckets.size)
Goal: (m.erase k).size = (m.erase k).buckets.size
-- Batteries.HashMap.Imp.erase_WF
theorem erase_WF [BEq α] [Hashable α] {m : Imp α β} {k}
    (h : m.buckets.WF) : (erase m k).buckets.WF 
Arguments: {α : Type u_1} {β : Type u_2} [BEq α] [Hashable α] {m : Batteries.HashMap.Imp α β} {k : α} (h : m.buckets.WF)
Goal: (m.erase k).buckets.WF
-- Batteries.HashMap.Imp.modify_size
theorem modify_size [BEq α] [Hashable α] {m : Imp α β} {k}
    (h : m.size = m.buckets.size) :
    (modify m k f).size = (modify m k f).buckets.size 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β → β} [BEq α] [Hashable α] {m : Batteries.HashMap.Imp α β} {k : α} (h : m.size = m.buckets.size)
Goal: (m.modify k f).size = (m.modify k f).buckets.size
-- Batteries.HashMap.Imp.modify_WF
theorem modify_WF [BEq α] [Hashable α] {m : Imp α β} {k}
    (h : m.buckets.WF) : (modify m k f).buckets.WF 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β → β} [BEq α] [Hashable α] {m : Batteries.HashMap.Imp α β} {k : α} (h : m.buckets.WF)
Goal: (m.modify k f).buckets.WF
-- Batteries.HashMap.Imp.WF.out
theorem WF.out [BEq α] [Hashable α] {m : Imp α β} (h : m.WF) :
    m.size = m.buckets.size ∧ m.buckets.WF 
Arguments: {α : Type u_1} {β : Type u_2} [BEq α] [Hashable α] {m : Batteries.HashMap.Imp α β} (h : m.WF)
Goal: m.size = m.buckets.size ∧ m.buckets.WF
-- Batteries.HashMap.Imp.WF_iff
theorem WF_iff [BEq α] [Hashable α] {m : Imp α β} :
    m.WF ↔ m.size = m.buckets.size ∧ m.buckets.WF 
Arguments: {α : Type u_1} {β : Type u_2} [BEq α] [Hashable α] {m : Batteries.HashMap.Imp α β}
Goal: m.WF ↔ m.size = m.buckets.size ∧ m.buckets.WF
-- Batteries.HashMap.Imp.WF.mapVal
theorem WF.mapVal {α β γ} {f : α → β → γ} [BEq α] [Hashable α]
    {m : Imp α β} (H : WF m) : WF (mapVal f m) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β → γ} [BEq α] [Hashable α] {m : Batteries.HashMap.Imp α β} (H : m.WF)
Goal: (Batteries.HashMap.Imp.mapVal f m).WF
-- Batteries.HashMap.Imp.WF.filterMap
theorem WF.filterMap {α β γ} {f : α → β → Option γ} [BEq α] [Hashable α]
    {m : Imp α β} (H : WF m) : WF (filterMap f m) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β → Option γ} [BEq α] [Hashable α] {m : Batteries.HashMap.Imp α β} (H : m.WF)
Goal: (Batteries.HashMap.Imp.filterMap f m).WF
-- Membership.mem.upper
theorem Membership.mem.upper {i : Nat} {r : Std.Range} (h : i ∈ r) : i < r.stop 
Arguments: {i : Nat} {r : Std.Range} (h : i ∈ r)
Goal: i < r.stop
-- Membership.mem.lower
theorem Membership.mem.lower {i : Nat} {r : Std.Range} (h : i ∈ r) : r.start ≤ i 
Arguments: {i : Nat} {r : Std.Range} (h : i ∈ r)
Goal: r.start ≤ i
-- Membership.get_elem_helper
theorem Membership.get_elem_helper {i n : Nat} {r : Std.Range} (h₁ : i ∈ r) (h₂ : r.stop = n) :
    i < n 
Arguments: {i n : Nat} {r : Std.Range} (h₁ : i ∈ r) (h₂ : r.stop = n)
Goal: i < n
-- eq_mp_eq_cast
@[simp] theorem eq_mp_eq_cast  (h : α = β) : Eq.mp  h = cast h 
Arguments: {α β : Sort u_1} (h : α = β)
Goal: h.mp = cast h
-- eq_mpr_eq_cast
@[simp] theorem eq_mpr_eq_cast (h : α = β) : Eq.mpr h = cast h.symm 
Arguments: {α β : Sort u_1} (h : α = β)
Goal: h.mpr = cast ⋯
-- cast_cast
@[simp] theorem cast_cast : ∀ (ha : α = β) (hb : β = γ) (a : α),
    cast hb (cast ha a) = cast (ha.trans hb) a
  
Arguments: {α β γ : Sort u_1} (ha : α = β) (hb : β = γ) (a : α)
Goal: cast hb (cast ha a) = cast ⋯ a
-- eq_true_eq_id
@[simp] theorem eq_true_eq_id : Eq True = id 
Goal: Eq True = id
-- proof_irrel_heq
theorem proof_irrel_heq {p q : Prop} (hp : p) (hq : q) : HEq hp hq 
Arguments: {p q : Prop} (hp : p) (hq : q)
Goal: HEq hp hq
-- not_not_em
theorem not_not_em (a : Prop) : ¬¬(a ∨ ¬a) 
Arguments: (a : Prop)
Goal: ¬¬(a ∨ ¬a)
-- and_self_iff
theorem and_self_iff : a ∧ a ↔ a 
Arguments: {a : Prop}
Goal: a ∧ a ↔ a
-- and_not_self_iff
theorem and_not_self_iff (a : Prop) : a ∧ ¬a ↔ False 
Arguments: (a : Prop)
Goal: a ∧ ¬a ↔ False
-- not_and_self_iff
theorem not_and_self_iff (a : Prop) : ¬a ∧ a ↔ False 
Arguments: (a : Prop)
Goal: ¬a ∧ a ↔ False
-- And.imp
theorem And.imp (f : a → c) (g : b → d) (h : a ∧ b) : c ∧ d 
Arguments: {a c b d : Prop} (f : a → c) (g : b → d) (h : a ∧ b)
Goal: c ∧ d
-- And.imp_left
theorem And.imp_left (h : a → b) : a ∧ c → b ∧ c 
Arguments: {a b c : Prop} (h : a → b)
Goal: a ∧ c → b ∧ c
-- And.imp_right
theorem And.imp_right (h : a → b) : c ∧ a → c ∧ b 
Arguments: {a b c : Prop} (h : a → b)
Goal: c ∧ a → c ∧ b
-- and_congr
theorem and_congr (h₁ : a ↔ c) (h₂ : b ↔ d) : a ∧ b ↔ c ∧ d 
Arguments: {a c b d : Prop} (h₁ : a ↔ c) (h₂ : b ↔ d)
Goal: a ∧ b ↔ c ∧ d
-- and_congr_left'
theorem and_congr_left' (h : a ↔ b) : a ∧ c ↔ b ∧ c 
Arguments: {a b c : Prop} (h : a ↔ b)
Goal: a ∧ c ↔ b ∧ c
-- and_congr_right'
theorem and_congr_right' (h : b ↔ c) : a ∧ b ↔ a ∧ c 
Arguments: {b c a : Prop} (h : b ↔ c)
Goal: a ∧ b ↔ a ∧ c
-- not_and_of_not_left
theorem not_and_of_not_left (b : Prop) : ¬a → ¬(a ∧ b) 
Arguments: {a : Prop} (b : Prop)
Goal: ¬a → ¬(a ∧ b)
-- not_and_of_not_right
theorem not_and_of_not_right (a : Prop) {b : Prop} : ¬b → ¬(a ∧ b) 
Arguments: (a : Prop) {b : Prop}
Goal: ¬b → ¬(a ∧ b)
-- and_congr_right_eq
theorem and_congr_right_eq (h : a → b = c) : (a ∧ b) = (a ∧ c) 
Arguments: {a b c : Prop} (h : a → b = c)
Goal: (a ∧ b) = (a ∧ c)
-- and_congr_left_eq
theorem and_congr_left_eq  (h : c → a = b) : (a ∧ c) = (b ∧ c) 
Arguments: {c a b : Prop} (h : c → a = b)
Goal: (a ∧ c) = (b ∧ c)
-- and_left_comm
theorem and_left_comm : a ∧ b ∧ c ↔ b ∧ a ∧ c 
Arguments: {a b c : Prop}
Goal: a ∧ b ∧ c ↔ b ∧ a ∧ c
-- and_right_comm
theorem and_right_comm : (a ∧ b) ∧ c ↔ (a ∧ c) ∧ b 
Arguments: {a b c : Prop}
Goal: (a ∧ b) ∧ c ↔ (a ∧ c) ∧ b
-- and_rotate
theorem and_rotate : a ∧ b ∧ c ↔ b ∧ c ∧ a 
Arguments: {a b c : Prop}
Goal: a ∧ b ∧ c ↔ b ∧ c ∧ a
-- and_and_and_comm
theorem and_and_and_comm : (a ∧ b) ∧ c ∧ d ↔ (a ∧ c) ∧ b ∧ d 
Arguments: {a b c d : Prop}
Goal: (a ∧ b) ∧ c ∧ d ↔ (a ∧ c) ∧ b ∧ d
-- and_and_left
theorem and_and_left  : a ∧ (b ∧ c) ↔ (a ∧ b) ∧ a ∧ c 
Arguments: {a b c : Prop}
Goal: a ∧ b ∧ c ↔ (a ∧ b) ∧ a ∧ c
-- and_and_right
theorem and_and_right : (a ∧ b) ∧ c ↔ (a ∧ c) ∧ b ∧ c 
Arguments: {a b c : Prop}
Goal: (a ∧ b) ∧ c ↔ (a ∧ c) ∧ b ∧ c
-- and_iff_left
theorem and_iff_left  (hb : b) : a ∧ b ↔ a 
Arguments: {b a : Prop} (hb : b)
Goal: a ∧ b ↔ a
-- and_iff_right
theorem and_iff_right (ha : a) : a ∧ b ↔ b 
Arguments: {a b : Prop} (ha : a)
Goal: a ∧ b ↔ b
-- or_self_iff
theorem or_self_iff : a ∨ a ↔ a 
Arguments: {a : Prop}
Goal: a ∨ a ↔ a
-- not_or_intro
theorem not_or_intro {a b : Prop} (ha : ¬a) (hb : ¬b) : ¬(a ∨ b) 
Arguments: {a b : Prop} (ha : ¬a) (hb : ¬b)
Goal: ¬(a ∨ b)
-- or_congr
theorem or_congr (h₁ : a ↔ c) (h₂ : b ↔ d) : (a ∨ b) ↔ (c ∨ d) 
Arguments: {a c b d : Prop} (h₁ : a ↔ c) (h₂ : b ↔ d)
Goal: a ∨ b ↔ c ∨ d
-- or_congr_left
theorem or_congr_left (h : a ↔ b) : a ∨ c ↔ b ∨ c 
Arguments: {a b c : Prop} (h : a ↔ b)
Goal: a ∨ c ↔ b ∨ c
-- or_congr_right
theorem or_congr_right (h : b ↔ c) : a ∨ b ↔ a ∨ c 
Arguments: {b c a : Prop} (h : b ↔ c)
Goal: a ∨ b ↔ a ∨ c
-- or_left_comm
theorem or_left_comm  : a ∨ (b ∨ c) ↔ b ∨ (a ∨ c) 
Arguments: {a b c : Prop}
Goal: a ∨ b ∨ c ↔ b ∨ a ∨ c
-- or_right_comm
theorem or_right_comm : (a ∨ b) ∨ c ↔ (a ∨ c) ∨ b 
Arguments: {a b c : Prop}
Goal: (a ∨ b) ∨ c ↔ (a ∨ c) ∨ b
-- or_or_or_comm
theorem or_or_or_comm : (a ∨ b) ∨ c ∨ d ↔ (a ∨ c) ∨ b ∨ d 
Arguments: {a b c d : Prop}
Goal: (a ∨ b) ∨ c ∨ d ↔ (a ∨ c) ∨ b ∨ d
-- or_or_distrib_left
theorem or_or_distrib_left : a ∨ b ∨ c ↔ (a ∨ b) ∨ a ∨ c 
Arguments: {a b c : Prop}
Goal: a ∨ b ∨ c ↔ (a ∨ b) ∨ a ∨ c
-- or_or_distrib_right
theorem or_or_distrib_right : (a ∨ b) ∨ c ↔ (a ∨ c) ∨ b ∨ c 
Arguments: {a b c : Prop}
Goal: (a ∨ b) ∨ c ↔ (a ∨ c) ∨ b ∨ c
-- or_rotate
theorem or_rotate : a ∨ b ∨ c ↔ b ∨ c ∨ a 
Arguments: {a b c : Prop}
Goal: a ∨ b ∨ c ↔ b ∨ c ∨ a
-- or_iff_left
theorem or_iff_left  (hb : ¬b) : a ∨ b ↔ a 
Arguments: {b a : Prop} (hb : ¬b)
Goal: a ∨ b ↔ a
-- or_iff_right
theorem or_iff_right (ha : ¬a) : a ∨ b ↔ b 
Arguments: {a b : Prop} (ha : ¬a)
Goal: a ∨ b ↔ b
-- not_imp_of_and_not
theorem not_imp_of_and_not : a ∧ ¬b → ¬(a → b)
  
Arguments: {a b : Prop}
Goal: a ∧ ¬b → ¬(a → b)
-- imp_and
theorem imp_and {α} : (α → b ∧ c) ↔ (α → b) ∧ (α → c) 
Arguments: {b c : Prop} {α : Sort u_1}
Goal: α → b ∧ c ↔ (α → b) ∧ (α → c)
-- not_and'
theorem not_and' : ¬(a ∧ b) ↔ b → ¬a 
Arguments: {a b : Prop}
Goal: ¬(a ∧ b) ↔ b → ¬a
-- and_or_left
theorem and_or_left : a ∧ (b ∨ c) ↔ (a ∧ b) ∨ (a ∧ c) 
Arguments: {a b c : Prop}
Goal: a ∧ (b ∨ c) ↔ a ∧ b ∨ a ∧ c
-- or_and_right
theorem or_and_right : (a ∨ b) ∧ c ↔ (a ∧ c) ∨ (b ∧ c) 
Arguments: {a b c : Prop}
Goal: (a ∨ b) ∧ c ↔ a ∧ c ∨ b ∧ c
-- or_and_left
theorem or_and_left : a ∨ (b ∧ c) ↔ (a ∨ b) ∧ (a ∨ c) 
Arguments: {a b c : Prop}
Goal: a ∨ b ∧ c ↔ (a ∨ b) ∧ (a ∨ c)
-- and_or_right
theorem and_or_right : (a ∧ b) ∨ c ↔ (a ∨ c) ∧ (b ∨ c) 
Arguments: {a b c : Prop}
Goal: a ∧ b ∨ c ↔ (a ∨ c) ∧ (b ∨ c)
-- or_imp
theorem or_imp : (a ∨ b → c) ↔ (a → c) ∧ (b → c) 
Arguments: {a b c : Prop}
Goal: a ∨ b → c ↔ (a → c) ∧ (b → c)
-- not_or
@[simp] theorem not_or : ¬(p ∨ q) ↔ ¬p ∧ ¬q 
Arguments: {p q : Prop}
Goal: ¬(p ∨ q) ↔ ¬p ∧ ¬q
-- not_and_of_not_or_not
theorem not_and_of_not_or_not (h : ¬a ∨ ¬b) : ¬(a ∧ b) 
Arguments: {a b : Prop} (h : ¬a ∨ ¬b)
Goal: ¬(a ∧ b)
-- if_false_left
@[simp]
theorem if_false_left [h : Decidable p] :
    ite p False q ↔ ¬p ∧ q 
Arguments: {p q : Prop} [h : Decidable p]
Goal: (if p then False else q) ↔ ¬p ∧ q
-- if_false_right
@[simp]
theorem if_false_right [h : Decidable p] :
    ite p q False ↔ p ∧ q 
Arguments: {p q : Prop} [h : Decidable p]
Goal: (if p then q else False) ↔ p ∧ q
-- if_true_left
@[simp low]
theorem if_true_left [h : Decidable p] :
    ite p True q ↔ ¬p → q 
Arguments: {p q : Prop} [h : Decidable p]
Goal: (if p then True else q) ↔ ¬p → q
-- if_true_right
@[simp low]
theorem if_true_right [h : Decidable p] :
    ite p q True ↔ p → q 
Arguments: {p q : Prop} [h : Decidable p]
Goal: (if p then q else True) ↔ p → q
-- dite_not
@[simp] theorem dite_not [hn : Decidable (¬p)] [h : Decidable p]  (x : ¬p → α) (y : ¬¬p → α) :
    dite (¬p) x y = dite p (fun h => y (not_not_intro h)) x 
Arguments: {p : Prop} {α : Sort u_1} [hn : Decidable ¬p] [h : Decidable p] (x : ¬p → α) (y : ¬¬p → α)
Goal: dite (¬p) x y = dite p (fun h => y ⋯) x
-- ite_not
@[simp] theorem ite_not (p : Prop) [Decidable p] (x y : α) : ite (¬p) x y = ite p y x 
Arguments: {α : Sort u_1} (p : Prop) [Decidable p] (x y : α)
Goal: (if ¬p then x else y) = if p then y else x
-- ite_true_same
@[simp] theorem ite_true_same (p q : Prop) [h : Decidable p] : (if p then p else q) = (¬p → q) 
Arguments: (p q : Prop) [h : Decidable p]
Goal: (if p then p else q) = (¬p → q)
-- ite_false_same
@[simp] theorem ite_false_same (p q : Prop) [h : Decidable p] : (if p then q else p) = (p ∧ q) 
Arguments: (p q : Prop) [h : Decidable p]
Goal: (if p then q else p) = (p ∧ q)
-- forall_imp
theorem forall_imp (h : ∀ a, p a → q a) : (∀ a, p a) → ∀ a, q a 
Arguments: {α : Sort u_1} {p q : α → Prop} (h : ∀ (a : α), p a → q a)
Goal: (∀ (a : α), p a) → ∀ (a : α), q a
-- forall_exists_index
@[simp] theorem forall_exists_index {q : (∃ x, p x) → Prop} :
    (∀ h, q h) ↔ ∀ x (h : p x), q ⟨x, h⟩ 
Arguments: {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}
Goal: (∀ (h : ∃ x, p x), q h) ↔ ∀ (x : α) (h : p x), q ⋯
-- Exists.imp
theorem Exists.imp (h : ∀ a, p a → q a) : (∃ a, p a) → ∃ a, q a
  
Arguments: {α : Sort u_1} {p q : α → Prop} (h : ∀ (a : α), p a → q a)
Goal: (∃ a, p a) → ∃ a, q a
-- Exists.imp'
theorem Exists.imp' {β} {q : β → Prop} (f : α → β) (hpq : ∀ a, p a → q (f a)) :
    (∃ a, p a) → ∃ b, q b
  
Arguments: {α : Sort u_2} {p : α → Prop} {β : Sort u_1} {q : β → Prop} (f : α → β) (hpq : ∀ (a : α), p a → q (f a))
Goal: (∃ a, p a) → ∃ b, q b
-- exists_imp
theorem exists_imp : ((∃ x, p x) → b) ↔ ∀ x, p x → b 
Arguments: {α : Sort u_1} {p : α → Prop} {b : Prop}
Goal: (∃ x, p x) → b ↔ ∀ (x : α), p x → b
-- exists_const
@[simp] theorem exists_const (α) [i : Nonempty α] : (∃ _ : α, b) ↔ b 
Arguments: {b : Prop} (α : Sort u_1) [i : Nonempty α]
Goal: (∃ x, b) ↔ b
-- forall_congr'
theorem forall_congr' (h : ∀ a, p a ↔ q a) : (∀ a, p a) ↔ ∀ a, q a 
Arguments: {α : Sort u_1} {p q : α → Prop} (h : ∀ (a : α), p a ↔ q a)
Goal: (∀ (a : α), p a) ↔ ∀ (a : α), q a
-- exists_congr
theorem exists_congr (h : ∀ a, p a ↔ q a) : (∃ a, p a) ↔ ∃ a, q a 
Arguments: {α : Sort u_1} {p q : α → Prop} (h : ∀ (a : α), p a ↔ q a)
Goal: (∃ a, p a) ↔ ∃ a, q a
-- forall₂_congr
theorem forall₂_congr {p q : ∀ a, β a → Prop} (h : ∀ a b, p a b ↔ q a b) :
    (∀ a b, p a b) ↔ ∀ a b, q a b 
Arguments: {α : Sort u_1} {β : α → Sort u_2} {p q : (a : α) → β a → Prop} (h : ∀ (a : α) (b : β a), p a b ↔ q a b)
Goal: (∀ (a : α) (b : β a), p a b) ↔ ∀ (a : α) (b : β a), q a b
-- exists₂_congr
theorem exists₂_congr {p q : ∀ a, β a → Prop} (h : ∀ a b, p a b ↔ q a b) :
    (∃ a b, p a b) ↔ ∃ a b, q a b 
Arguments: {α : Sort u_1} {β : α → Sort u_2} {p q : (a : α) → β a → Prop} (h : ∀ (a : α) (b : β a), p a b ↔ q a b)
Goal: (∃ a b, p a b) ↔ ∃ a b, q a b