ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Batteries.RBNode.balance2_All
@[simp] theorem balance2_All {l : RBNode α} {v : α} {r : RBNode α} :
    (balance2 l v r).All p ↔ p v ∧ l.All p ∧ r.All p 
Arguments: {α : Type u_1} {p : α → Prop} {l : Batteries.RBNode α} {v : α} {r : Batteries.RBNode α}
Goal: Batteries.RBNode.All p (l.balance2 v r) ↔ p v ∧ Batteries.RBNode.All p l ∧ Batteries.RBNode.All p r
-- Batteries.RBNode.reverse_setBlack
@[simp] theorem reverse_setBlack {t : RBNode α} : (setBlack t).reverse = setBlack t.reverse 
Arguments: {α : Type u_1} {t : Batteries.RBNode α}
Goal: t.setBlack.reverse = t.reverse.setBlack
-- Batteries.RBNode.Ordered.setBlack
protected theorem Ordered.setBlack {t : RBNode α} : (setBlack t).Ordered cmp ↔ t.Ordered cmp 
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {t : Batteries.RBNode α}
Goal: Batteries.RBNode.Ordered cmp t.setBlack ↔ Batteries.RBNode.Ordered cmp t
-- Batteries.RBNode.Balanced.setBlack
protected theorem Balanced.setBlack : t.Balanced c n → ∃ n', (setBlack t).Balanced black n'
  
Goal: ∀ {α : Type u_1} {t : Batteries.RBNode α} {c : Batteries.RBColor} {n : Nat},
  t.Balanced c n → ∃ n', t.setBlack.Balanced Batteries.RBColor.black n'
-- Batteries.RBNode.setBlack_idem
theorem setBlack_idem {t : RBNode α} : t.setBlack.setBlack = t.setBlack 
Arguments: {α : Type u_1} {t : Batteries.RBNode α}
Goal: t.setBlack.setBlack = t.setBlack
-- Batteries.RBNode.reverse_ins
@[simp] theorem reverse_ins [inst : @OrientedCmp α cmp] {t : RBNode α} :
    (ins cmp x t).reverse = ins (flip cmp) x t.reverse 
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {x : α} [inst : Batteries.OrientedCmp cmp] {t : Batteries.RBNode α}
Goal: (Batteries.RBNode.ins cmp x t).reverse = Batteries.RBNode.ins (flip cmp) x t.reverse
-- Batteries.RBNode.All.ins
protected theorem All.ins {x : α} {t : RBNode α}
  (h₁ : p x) (h₂ : t.All p) : (ins cmp x t).All p 
Arguments: {α : Type u_1} {p : α → Prop} {cmp : α → α → Ordering} {x : α} {t : Batteries.RBNode α} (h₁ : p x) (h₂ : Batteries.RBNode.All p t)
Goal: Batteries.RBNode.All p (Batteries.RBNode.ins cmp x t)
-- Batteries.RBNode.Ordered.ins
protected theorem Ordered.ins : ∀ {t : RBNode α}, t.Ordered cmp → (ins cmp x t).Ordered cmp
  
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {x : α} {t : Batteries.RBNode α}
Goal: Batteries.RBNode.Ordered cmp t → Batteries.RBNode.Ordered cmp (Batteries.RBNode.ins cmp x t)
-- Batteries.RBNode.isRed_reverse
@[simp] theorem isRed_reverse {t : RBNode α} : t.reverse.isRed = t.isRed 
Arguments: {α : Type u_1} {t : Batteries.RBNode α}
Goal: t.reverse.isRed = t.isRed
-- Batteries.RBNode.reverse_insert
@[simp] theorem reverse_insert [inst : @OrientedCmp α cmp] {t : RBNode α} :
    (insert cmp t x).reverse = insert (flip cmp) t.reverse x 
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {x : α} [inst : Batteries.OrientedCmp cmp] {t : Batteries.RBNode α}
Goal: (Batteries.RBNode.insert cmp t x).reverse = Batteries.RBNode.insert (flip cmp) t.reverse x
-- Batteries.RBNode.insert_setBlack
theorem insert_setBlack {t : RBNode α} :
    (t.insert cmp v).setBlack = (t.ins cmp v).setBlack 
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {v : α} {t : Batteries.RBNode α}
Goal: (Batteries.RBNode.insert cmp t v).setBlack = (Batteries.RBNode.ins cmp v t).setBlack
-- Batteries.RBNode.Ordered.insert
protected theorem Ordered.insert (h : t.Ordered cmp) : (insert cmp t v).Ordered cmp 
Goal: ∀ {α : Type u_1} {cmp : α → α → Ordering} {t : Batteries.RBNode α} {v : α},
  Batteries.RBNode.Ordered cmp t → Batteries.RBNode.Ordered cmp (Batteries.RBNode.insert cmp t v)
-- Batteries.RBNode.RedRed.of_false
protected theorem RedRed.of_false (h : ¬p) : RedRed p t n → ∃ c, Balanced t c n
  
Arguments: {p : Prop}
Goal: ∀ {α : Type u_1} {t : Batteries.RBNode α} {n : Nat}, ¬p → Batteries.RBNode.RedRed p t n → ∃ c, t.Balanced c n
-- Batteries.RBNode.RedRed.of_red
protected theorem RedRed.of_red : RedRed p (node red a x b) n →
    ∃ c₁ c₂, Balanced a c₁ n ∧ Balanced b c₂ n
  
Arguments: {p : Prop}
Goal: ∀ {α : Type u_1} {a : Batteries.RBNode α} {x : α} {b : Batteries.RBNode α} {n : Nat},
  Batteries.RBNode.RedRed p (Batteries.RBNode.node Batteries.RBColor.red a x b) n →
    ∃ c₁ c₂, a.Balanced c₁ n ∧ b.Balanced c₂ n
-- Batteries.RBNode.RedRed.imp
protected theorem RedRed.imp (h : p → q) : RedRed p t n → RedRed q t n
  
Arguments: {p q : Prop}
Goal: ∀ {α : Type u_1} {t : Batteries.RBNode α} {n : Nat},
  (p → q) → Batteries.RBNode.RedRed p t n → Batteries.RBNode.RedRed q t n
-- Batteries.RBNode.RedRed.reverse
protected theorem RedRed.reverse : RedRed p t n → RedRed p t.reverse n
  
Arguments: {p : Prop}
Goal: ∀ {α : Type u_1} {t : Batteries.RBNode α} {n : Nat},
  Batteries.RBNode.RedRed p t n → Batteries.RBNode.RedRed p t.reverse n
-- Batteries.RBNode.RedRed.setBlack
protected theorem RedRed.setBlack : t.RedRed p n → ∃ n', (setBlack t).Balanced black n'
  
Goal: ∀ {α : Type u_1} {t : Batteries.RBNode α} {p : Prop} {n : Nat},
  Batteries.RBNode.RedRed p t n → ∃ n', t.setBlack.Balanced Batteries.RBColor.black n'
-- Batteries.RBNode.RedRed.balance1
protected theorem RedRed.balance1 {l : RBNode α} {v : α} {r : RBNode α}
    (hl : l.RedRed p n) (hr : r.Balanced c n) : ∃ c, (balance1 l v r).Balanced c (n + 1) 
Arguments: {α : Type u_1} {p : Prop} {n : Nat} {c : Batteries.RBColor} {l : Batteries.RBNode α} {v : α} {r : Batteries.RBNode α} (hl : Batteries.RBNode.RedRed p l n) (hr : r.Balanced c n)
Goal: ∃ c, (l.balance1 v r).Balanced c (n + 1)
-- Batteries.RBNode.RedRed.balance2
protected theorem RedRed.balance2 {l : RBNode α} {v : α} {r : RBNode α}
    (hl : l.Balanced c n) (hr : r.RedRed p n) : ∃ c, (balance2 l v r).Balanced c (n + 1) 
Arguments: {α : Type u_1} {c : Batteries.RBColor} {n : Nat} {p : Prop} {l : Batteries.RBNode α} {v : α} {r : Batteries.RBNode α} (hl : l.Balanced c n) (hr : Batteries.RBNode.RedRed p r n)
Goal: ∃ c, (l.balance2 v r).Balanced c (n + 1)
-- Batteries.RBNode.balance1_eq
theorem balance1_eq {l : RBNode α} {v : α} {r : RBNode α}
    (hl : l.Balanced c n) : balance1 l v r = node black l v r 
Arguments: {α : Type u_1} {c : Batteries.RBColor} {n : Nat} {l : Batteries.RBNode α} {v : α} {r : Batteries.RBNode α} (hl : l.Balanced c n)
Goal: l.balance1 v r = Batteries.RBNode.node Batteries.RBColor.black l v r
-- Batteries.RBNode.balance2_eq
theorem balance2_eq {l : RBNode α} {v : α} {r : RBNode α}
    (hr : r.Balanced c n) : balance2 l v r = node black l v r 
Arguments: {α : Type u_1} {c : Batteries.RBColor} {n : Nat} {l : Batteries.RBNode α} {v : α} {r : Batteries.RBNode α} (hr : r.Balanced c n)
Goal: l.balance2 v r = Batteries.RBNode.node Batteries.RBColor.black l v r
-- Batteries.RBNode.Balanced.ins
protected theorem Balanced.ins (cmp v) {t : RBNode α}
    (h : t.Balanced c n) : (ins cmp v t).RedRed (t.isRed = red) n 
Arguments: {α : Type u_1} {c : Batteries.RBColor} {n : Nat} (cmp : α → α → Ordering) (v : α) {t : Batteries.RBNode α} (h : t.Balanced c n)
Goal: Batteries.RBNode.RedRed (t.isRed = Batteries.RBColor.red) (Batteries.RBNode.ins cmp v t) n
-- Batteries.RBNode.Balanced.insert
theorem Balanced.insert {t : RBNode α} (h : t.Balanced c n) :
    ∃ c' n', (insert cmp t v).Balanced c' n' 
Arguments: {α : Type u_1} {c : Batteries.RBColor} {n : Nat} {cmp : α → α → Ordering} {v : α} {t : Batteries.RBNode α} (h : t.Balanced c n)
Goal: ∃ c' n', (Batteries.RBNode.insert cmp t v).Balanced c' n'
-- Batteries.RBNode.reverse_setRed
@[simp] theorem reverse_setRed {t : RBNode α} : (setRed t).reverse = setRed t.reverse 
Arguments: {α : Type u_1} {t : Batteries.RBNode α}
Goal: t.setRed.reverse = t.reverse.setRed
-- Batteries.RBNode.All.setRed
protected theorem All.setRed {t : RBNode α} (h : t.All p) : (setRed t).All p 
Arguments: {α : Type u_1} {p : α → Prop} {t : Batteries.RBNode α} (h : Batteries.RBNode.All p t)
Goal: Batteries.RBNode.All p t.setRed
-- Batteries.RBNode.Ordered.setRed
protected theorem Ordered.setRed {t : RBNode α} : (setRed t).Ordered cmp ↔ t.Ordered cmp 
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {t : Batteries.RBNode α}
Goal: Batteries.RBNode.Ordered cmp t.setRed ↔ Batteries.RBNode.Ordered cmp t
-- Batteries.RBNode.reverse_balLeft
@[simp] theorem reverse_balLeft (l : RBNode α) (v : α) (r : RBNode α) :
    (balLeft l v r).reverse = balRight r.reverse v l.reverse 
Arguments: {α : Type u_1} (l : Batteries.RBNode α) (v : α) (r : Batteries.RBNode α)
Goal: (l.balLeft v r).reverse = r.reverse.balRight v l.reverse
-- Batteries.RBNode.reverse_balRight
@[simp] theorem reverse_balRight (l : RBNode α) (v : α) (r : RBNode α) :
    (balRight l v r).reverse = balLeft r.reverse v l.reverse 
Arguments: {α : Type u_1} (l : Batteries.RBNode α) (v : α) (r : Batteries.RBNode α)
Goal: (l.balRight v r).reverse = r.reverse.balLeft v l.reverse
-- Batteries.RBNode.All.balLeft
protected theorem All.balLeft
    (hl : l.All p) (hv : p v) (hr : r.All p) : (balLeft l v r).All p 
Goal: ∀ {α : Type u_1} {p : α → Prop} {l : Batteries.RBNode α} {v : α} {r : Batteries.RBNode α},
  Batteries.RBNode.All p l → p v → Batteries.RBNode.All p r → Batteries.RBNode.All p (l.balLeft v r)
-- Batteries.RBNode.Ordered.balLeft
protected theorem Ordered.balLeft {l : RBNode α} {v : α} {r : RBNode α}
    (lv : l.All (cmpLT cmp · v)) (vr : r.All (cmpLT cmp v ·))
    (hl : l.Ordered cmp) (hr : r.Ordered cmp) : (balLeft l v r).Ordered cmp 
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {l : Batteries.RBNode α} {v : α} {r : Batteries.RBNode α} (lv : Batteries.RBNode.All (fun x => Batteries.RBNode.cmpLT cmp x v) l) (vr : Batteries.RBNode.All (fun x => Batteries.RBNode.cmpLT cmp v x) r) (hl : Batteries.RBNode.Ordered cmp l) (hr : Batteries.RBNode.Ordered cmp r)
Goal: Batteries.RBNode.Ordered cmp (l.balLeft v r)
-- Batteries.RBNode.Balanced.balLeft
protected theorem Balanced.balLeft (hl : l.RedRed True n) (hr : r.Balanced cr (n + 1)) :
    (balLeft l v r).RedRed (cr = red) (n + 1) 
Goal: ∀ {α : Type u_1} {l : Batteries.RBNode α} {v : α} {r : Batteries.RBNode α} {cr : Batteries.RBColor} {n : Nat},
  Batteries.RBNode.RedRed True l n →
    r.Balanced cr (n + 1) → Batteries.RBNode.RedRed (cr = Batteries.RBColor.red) (l.balLeft v r) (n + 1)
-- Batteries.RBNode.All.balRight
protected theorem All.balRight
    (hl : l.All p) (hv : p v) (hr : r.All p) : (balRight l v r).All p 
Goal: ∀ {α : Type u_1} {p : α → Prop} {l : Batteries.RBNode α} {v : α} {r : Batteries.RBNode α},
  Batteries.RBNode.All p l → p v → Batteries.RBNode.All p r → Batteries.RBNode.All p (l.balRight v r)
-- Batteries.RBNode.Ordered.balRight
protected theorem Ordered.balRight {l : RBNode α} {v : α} {r : RBNode α}
    (lv : l.All (cmpLT cmp · v)) (vr : r.All (cmpLT cmp v ·))
    (hl : l.Ordered cmp) (hr : r.Ordered cmp) : (balRight l v r).Ordered cmp 
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {l : Batteries.RBNode α} {v : α} {r : Batteries.RBNode α} (lv : Batteries.RBNode.All (fun x => Batteries.RBNode.cmpLT cmp x v) l) (vr : Batteries.RBNode.All (fun x => Batteries.RBNode.cmpLT cmp v x) r) (hl : Batteries.RBNode.Ordered cmp l) (hr : Batteries.RBNode.Ordered cmp r)
Goal: Batteries.RBNode.Ordered cmp (l.balRight v r)
-- Batteries.RBNode.Balanced.balRight
protected theorem Balanced.balRight (hl : l.Balanced cl (n + 1)) (hr : r.RedRed True n) :
    (balRight l v r).RedRed (cl = red) (n + 1) 
Goal: ∀ {α : Type u_1} {l : Batteries.RBNode α} {v : α} {r : Batteries.RBNode α} {cl : Batteries.RBColor} {n : Nat},
  l.Balanced cl (n + 1) →
    Batteries.RBNode.RedRed True r n → Batteries.RBNode.RedRed (cl = Batteries.RBColor.red) (l.balRight v r) (n + 1)
-- Batteries.RBNode.All.append
protected theorem All.append (hl : l.All p) (hr : r.All p) : (append l r).All p 
Goal: ∀ {α : Type u_1} {l r : Batteries.RBNode α} {p : α → Prop},
  Batteries.RBNode.All p l → Batteries.RBNode.All p r → Batteries.RBNode.All p (l.append r)
-- Batteries.RBNode.Ordered.append
protected theorem Ordered.append {l : RBNode α} {v : α} {r : RBNode α}
    (lv : l.All (cmpLT cmp · v)) (vr : r.All (cmpLT cmp v ·))
    (hl : l.Ordered cmp) (hr : r.Ordered cmp) : (append l r).Ordered cmp 
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {l : Batteries.RBNode α} {v : α} {r : Batteries.RBNode α} (lv : Batteries.RBNode.All (fun x => Batteries.RBNode.cmpLT cmp x v) l) (vr : Batteries.RBNode.All (fun x => Batteries.RBNode.cmpLT cmp v x) r) (hl : Batteries.RBNode.Ordered cmp l) (hr : Batteries.RBNode.Ordered cmp r)
Goal: Batteries.RBNode.Ordered cmp (l.append r)
-- Batteries.RBNode.Balanced.append
protected theorem Balanced.append {l r : RBNode α}
    (hl : l.Balanced c₁ n) (hr : r.Balanced c₂ n) :
    (l.append r).RedRed (c₁ = black → c₂ ≠ black) n 
Arguments: {α : Type u_1} {c₁ : Batteries.RBColor} {n : Nat} {c₂ : Batteries.RBColor} {l r : Batteries.RBNode α} (hl : l.Balanced c₁ n) (hr : r.Balanced c₂ n)
Goal: Batteries.RBNode.RedRed (c₁ = Batteries.RBColor.black → c₂ ≠ Batteries.RBColor.black) (l.append r) n
-- Batteries.RBNode.DelProp.redred
theorem DelProp.redred (h : DelProp c t n) : ∃ n', RedRed (c = black) t n' 
Arguments: {c : Batteries.RBColor}
Goal: ∀ {α : Type u_1} {t : Batteries.RBNode α} {n : Nat},
  Batteries.RBNode.DelProp c t n → ∃ n', Batteries.RBNode.RedRed (c = Batteries.RBColor.black) t n'
-- Batteries.RBNode.All.del
protected theorem All.del : ∀ {t : RBNode α}, t.All p → (del cut t).All p
  
Arguments: {α : Type u_1} {p : α → Prop} {cut : α → Ordering} {t : Batteries.RBNode α}
Goal: Batteries.RBNode.All p t → Batteries.RBNode.All p (Batteries.RBNode.del cut t)
-- Batteries.RBNode.Ordered.del
protected theorem Ordered.del : ∀ {t : RBNode α}, t.Ordered cmp → (del cut t).Ordered cmp
  
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering} {t : Batteries.RBNode α}
Goal: Batteries.RBNode.Ordered cmp t → Batteries.RBNode.Ordered cmp (Batteries.RBNode.del cut t)
-- Batteries.RBNode.Balanced.del
protected theorem Balanced.del {t : RBNode α} (h : t.Balanced c n) :
    (t.del cut).DelProp t.isBlack n 
Arguments: {α : Type u_1} {c : Batteries.RBColor} {n : Nat} {cut : α → Ordering} {t : Batteries.RBNode α} (h : t.Balanced c n)
Goal: Batteries.RBNode.DelProp t.isBlack (Batteries.RBNode.del cut t) n
-- Batteries.RBNode.Ordered.erase
protected theorem Ordered.erase {t : RBNode α} (h : t.Ordered cmp) : (erase cut t).Ordered cmp 
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering} {t : Batteries.RBNode α} (h : Batteries.RBNode.Ordered cmp t)
Goal: Batteries.RBNode.Ordered cmp (Batteries.RBNode.erase cut t)
-- Batteries.RBNode.Balanced.erase
protected theorem Balanced.erase {t : RBNode α}
    (h : t.Balanced c n) : ∃ n, (t.erase cut).Balanced black n 
Arguments: {α : Type u_1} {c : Batteries.RBColor} {n : Nat} {cut : α → Ordering} {t : Batteries.RBNode α} (h : t.Balanced c n)
Goal: ∃ n, (Batteries.RBNode.erase cut t).Balanced Batteries.RBColor.black n
-- Batteries.RBNode.WF.out
theorem WF.out {t : RBNode α} (h : t.WF cmp) : t.Ordered cmp ∧ ∃ c n, t.Balanced c n 
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {t : Batteries.RBNode α} (h : Batteries.RBNode.WF cmp t)
Goal: Batteries.RBNode.Ordered cmp t ∧ ∃ c n, t.Balanced c n
-- Batteries.RBNode.WF_iff
@[simp] theorem WF_iff {t : RBNode α} : t.WF cmp ↔ t.Ordered cmp ∧ ∃ c n, t.Balanced c n 
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {t : Batteries.RBNode α}
Goal: Batteries.RBNode.WF cmp t ↔ Batteries.RBNode.Ordered cmp t ∧ ∃ c n, t.Balanced c n
-- Batteries.RBNode.Balanced.map
protected theorem Balanced.map {t : RBNode α} : t.Balanced c n → (t.map f).Balanced c n
  
Arguments: {α : Type u_1} {c : Batteries.RBColor} {n : Nat}
Goal: ∀ {α_1 : Type u_2} {f : α → α_1} {t : Batteries.RBNode α}, t.Balanced c n → (Batteries.RBNode.map f t).Balanced c n
-- Batteries.RBNode.IsMonotone.lt_mono
class IsMonotone (cmpα cmpβ) (f : α → β) : Prop where
    lt_mono : cmpLT cmpα x y → cmpLT cmpβ (f x) (f y)
Arguments: {α : Sort u_1} {β : Sort u_2} {cmpα : α → α → Ordering} {cmpβ : β → β → Ordering} {f : α → β} [self : Batteries.RBSet.IsMonotone cmpα cmpβ f] {x y : α}
Goal: Batteries.RBNode.cmpLT cmpα x y → Batteries.RBNode.cmpLT cmpβ (f x) (f y)
-- Batteries.RBNode.All.map
protected theorem All.map {f : α → β} (H : ∀ {x}, p x → q (f x)) :
    ∀ {t : RBNode α}, t.All p → (t.map f).All q
  
Arguments: {α : Type u_1} {β : Type u_2} {p : α → Prop} {q : β → Prop} {f : α → β} (H : ∀ {x : α}, p x → q (f x)) {t : Batteries.RBNode α}
Goal: Batteries.RBNode.All p t → Batteries.RBNode.All q (Batteries.RBNode.map f t)
-- Batteries.RBNode.Ordered.map
protected theorem Ordered.map (f : α → β) [IsMonotone cmpα cmpβ f] :
    ∀ {t : RBNode α}, t.Ordered cmpα → (t.map f).Ordered cmpβ
  
Arguments: {α : Type u_1} {β : Type u_2} {cmpα : α → α → Ordering} {cmpβ : β → β → Ordering} (f : α → β) [Batteries.RBSet.IsMonotone cmpα cmpβ f] {t : Batteries.RBNode α}
Goal: Batteries.RBNode.Ordered cmpα t → Batteries.RBNode.Ordered cmpβ (Batteries.RBNode.map f t)
-- Lake.FamilyDef.family_key_eq_type
class FamilyDef {α : Type u} (Fam : α → Type v) (a : α) (β : semiOutParam $ Type v) : Prop where
  family_key_eq_type : Fam a = β
Arguments: {α : Type u} {Fam : α → Type v} {a : α} {β : semiOutParam (Type v)} [self : Lake.FamilyDef Fam a β]
Goal: Fam a = β
-- Lake.FamilyOut.family_key_eq_type
class FamilyOut {α : Type u} (Fam : α → Type v) (a : α) (β : outParam $ Type v) : Prop where
  family_key_eq_type : Fam a = β
Arguments: {α : Type u} {Fam : α → Type v} {a : α} {β : outParam (Type v)} [self : Lake.FamilyOut Fam a β]
Goal: Fam a = β
-- Lake.EqOfCmp.eq_of_cmp
class EqOfCmp (α : Type u) (cmp : α → α → Ordering) where
  eq_of_cmp {a a' : α} : cmp a a' = .eq → a = a'
Arguments: {α : Type u} {cmp : α → α → Ordering} [self : Lake.EqOfCmp α cmp] {a a' : α}
Goal: cmp a a' = Ordering.eq → a = a'
-- Lake.LawfulCmpEq.cmp_rfl
class LawfulCmpEq (α : Type u) (cmp : α → α → Ordering) extends EqOfCmp α cmp where
  cmp_rfl {a : α} : cmp a a = .eq
Arguments: {α : Type u} {cmp : α → α → Ordering} [self : Lake.LawfulCmpEq α cmp] {a : α}
Goal: cmp a a = Ordering.eq
-- Lake.cmp_iff_eq
@[simp] theorem cmp_iff_eq [LawfulCmpEq α cmp] : cmp a a' = .eq ↔ a = a' 
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {a a' : α} [Lake.LawfulCmpEq α cmp]
Goal: cmp a a' = Ordering.eq ↔ a = a'
-- Lake.EqOfCmpWrt.eq_of_cmp_wrt
class EqOfCmpWrt (α : Type u) {β : Type v} (f : α → β) (cmp : α → α → Ordering) where
  eq_of_cmp_wrt {a a' : α} : cmp a a' = .eq → f a = f a'
Arguments: {α : Type u} {β : Type v} {f : α → β} {cmp : α → α → Ordering} [self : Lake.EqOfCmpWrt α f cmp] {a a' : α}
Goal: cmp a a' = Ordering.eq → f a = f a'
-- Lake.eq_of_compareOfLessAndEq
theorem eq_of_compareOfLessAndEq [LT α] [DecidableEq α] {a a' : α}
[Decidable (a < a')] (h : compareOfLessAndEq a a' = .eq) : a = a' 
Arguments: {α : Type u_1} [LT α] [DecidableEq α] {a a' : α} [Decidable (a < a')] (h : compareOfLessAndEq a a' = Ordering.eq)
Goal: a = a'
-- Lake.compareOfLessAndEq_rfl
theorem compareOfLessAndEq_rfl [LT α] [DecidableEq α] {a : α}
[Decidable (a < a)] (lt_irrefl : ¬ a < a) : compareOfLessAndEq a a = .eq 
Arguments: {α : Type u_1} [LT α] [DecidableEq α] {a : α} [Decidable (a < a)] (lt_irrefl : ¬a < a)
Goal: compareOfLessAndEq a a = Ordering.eq
-- Lake.Fin.eq_of_compare
theorem Fin.eq_of_compare {n n' : Fin m} (h : compare n n' = .eq) : n = n' 
Arguments: {m : Nat} {n n' : Fin m} (h : compare n n' = Ordering.eq)
Goal: n = n'
-- Lake.List.lt_irrefl
theorem List.lt_irrefl [LT α] (irrefl_α : ∀ a : α, ¬ a < a)
: (a : List α) → ¬ a < a

Arguments: {α : Type u_1} [LT α] (irrefl_α : ∀ (a : α), ¬a < a) (a : List α)
Goal: ¬a < a
-- Lake.String.lt_irrefl
@[simp] theorem String.lt_irrefl (s : String) : ¬ s < s 
Arguments: (s : String)
Goal: ¬s < s
-- Lake.Name.beq_false
@[simp] protected theorem beq_false (m n : Name) : (m == n) = false ↔ ¬ (m = n) 
Arguments: (m n : Lake.Name)
Goal: (m == n) = false ↔ ¬m = n
-- Lake.Name.isPrefixOf_self
@[simp] theorem isPrefixOf_self {n : Name} : n.isPrefixOf n 
Arguments: {n : Lake.Name}
Goal: n.isPrefixOf n = true
-- Lake.Name.isPrefixOf_append
@[simp] theorem isPrefixOf_append {n m : Name} : ¬ n.hasMacroScopes → ¬ m.hasMacroScopes → n.isPrefixOf (n ++ m) 
Arguments: {n m : Lake.Name}
Goal: ¬n.hasMacroScopes = true → ¬m.hasMacroScopes = true → n.isPrefixOf (n ++ m) = true
-- Lake.Name.quickCmpAux_iff_eq
@[simp] theorem quickCmpAux_iff_eq : ∀ {n n'}, quickCmpAux n n' = .eq ↔ n = n'

Arguments: {n n' : Lake.Name}
Goal: n.quickCmpAux n' = Ordering.eq ↔ n = n'
-- Lake.Name.eq_of_quickCmp
theorem eq_of_quickCmp {n n' : Name} : n.quickCmp n' = .eq → n = n' 
Arguments: {n n' : Lake.Name}
Goal: n.quickCmp n' = Ordering.eq → n = n'
-- Lake.Name.quickCmp_rfl
theorem quickCmp_rfl {n : Name} : n.quickCmp n = .eq 
Arguments: {n : Lake.Name}
Goal: n.quickCmp n = Ordering.eq
-- BitVec.ofFin_eq_ofNat
theorem ofFin_eq_ofNat : @BitVec.ofFin w (Fin.mk x lt) = BitVec.ofNat w x 
Arguments: {w x : Nat} {lt : x < 2 ^ w}
Goal: { toFin := ⟨x, lt⟩ } = BitVec.ofNat w x
-- BitVec.eq_of_toNat_eq
theorem eq_of_toNat_eq {n} : ∀ {i j : BitVec n}, i.toNat = j.toNat → i = j
  
Arguments: {n : Nat} {i j : BitVec n}
Goal: i.toNat = j.toNat → i = j
-- BitVec.val_toFin
@[simp] theorem val_toFin (x : BitVec w) : x.toFin.val = x.toNat 
Arguments: {w : Nat} (x : BitVec w)
Goal: ↑x.toFin = x.toNat
-- BitVec.toNat_eq
@[bv_toNat] theorem toNat_eq (x y : BitVec n) : x = y ↔ x.toNat = y.toNat 
Arguments: {n : Nat} (x y : BitVec n)
Goal: x = y ↔ x.toNat = y.toNat
-- BitVec.toNat_ne
@[bv_toNat] theorem toNat_ne (x y : BitVec n) : x ≠ y ↔ x.toNat ≠ y.toNat 
Arguments: {n : Nat} (x y : BitVec n)
Goal: x ≠ y ↔ x.toNat ≠ y.toNat
-- BitVec.testBit_toNat
theorem testBit_toNat (x : BitVec w) : x.toNat.testBit i = x.getLsb i 
Arguments: {w i : Nat} (x : BitVec w)
Goal: x.toNat.testBit i = x.getLsb i
-- BitVec.getLsb_ofFin
@[simp] theorem getLsb_ofFin (x : Fin (2^n)) (i : Nat) :
  getLsb (BitVec.ofFin x) i = x.val.testBit i 
Arguments: {n : Nat} (x : Fin (2 ^ n)) (i : Nat)
Goal: { toFin := x }.getLsb i = (↑x).testBit i
-- BitVec.getLsb_ge
@[simp] theorem getLsb_ge (x : BitVec w) (i : Nat) (ge : w ≤ i) : getLsb x i = false 
Arguments: {w : Nat} (x : BitVec w) (i : Nat) (ge : w ≤ i)
Goal: x.getLsb i = false
-- BitVec.getMsb_ge
@[simp] theorem getMsb_ge (x : BitVec w) (i : Nat) (ge : w ≤ i) : getMsb x i = false 
Arguments: {w : Nat} (x : BitVec w) (i : Nat) (ge : w ≤ i)
Goal: x.getMsb i = false
-- BitVec.lt_of_getLsb
theorem lt_of_getLsb (x : BitVec w) (i : Nat) : getLsb x i = true → i < w 
Arguments: {w : Nat} (x : BitVec w) (i : Nat)
Goal: x.getLsb i = true → i < w
-- BitVec.lt_of_getMsb
theorem lt_of_getMsb (x : BitVec w) (i : Nat) : getMsb x i = true → i < w 
Arguments: {w : Nat} (x : BitVec w) (i : Nat)
Goal: x.getMsb i = true → i < w
-- BitVec.getMsb_eq_getLsb
theorem getMsb_eq_getLsb (x : BitVec w) (i : Nat) : x.getMsb i = (decide (i < w) && x.getLsb (w - 1 - i)) 
Arguments: {w : Nat} (x : BitVec w) (i : Nat)
Goal: x.getMsb i = (decide (i < w) && x.getLsb (w - 1 - i))
-- BitVec.getLsb_eq_getMsb
theorem getLsb_eq_getMsb (x : BitVec w) (i : Nat) : x.getLsb i = (decide (i < w) && x.getMsb (w - 1 - i)) 
Arguments: {w : Nat} (x : BitVec w) (i : Nat)
Goal: x.getLsb i = (decide (i < w) && x.getMsb (w - 1 - i))
-- BitVec.eq_of_getLsb_eq
@[ext] theorem eq_of_getLsb_eq {x y : BitVec w}
    (pred : ∀(i : Fin w), x.getLsb i.val = y.getLsb i.val) : x = y 
Arguments: {w : Nat} {x y : BitVec w} (pred : ∀ (i : Fin w), x.getLsb ↑i = y.getLsb ↑i)
Goal: x = y
-- BitVec.eq_of_getMsb_eq
theorem eq_of_getMsb_eq {x y : BitVec w}
    (pred : ∀(i : Fin w), x.getMsb i = y.getMsb i.val) : x = y 
Arguments: {w : Nat} {x y : BitVec w} (pred : ∀ (i : Fin w), x.getMsb ↑i = y.getMsb ↑i)
Goal: x = y
-- BitVec.of_length_zero
theorem of_length_zero {x : BitVec 0} : x = 0#0 
Arguments: {x : BitVec 0}
Goal: x = 0#0
-- BitVec.toNat_zero_length
@[simp] theorem toNat_zero_length (x : BitVec 0) : x.toNat = 0 
Arguments: (x : BitVec 0)
Goal: x.toNat = 0
-- BitVec.getLsb_zero_length
@[simp] theorem getLsb_zero_length (x : BitVec 0) : x.getLsb i = false 
Arguments: {i : Nat} (x : BitVec 0)
Goal: x.getLsb i = false
-- BitVec.getMsb_zero_length
@[simp] theorem getMsb_zero_length (x : BitVec 0) : x.getMsb i = false 
Arguments: {i : Nat} (x : BitVec 0)
Goal: x.getMsb i = false
-- BitVec.msb_zero_length
@[simp] theorem msb_zero_length (x : BitVec 0) : x.msb = false 
Arguments: (x : BitVec 0)
Goal: x.msb = false