ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Quotient.inductionOn
@[elab_as_elim]
protected theorem inductionOn {α : Sort u} {s : Setoid α} {motive : Quotient s → Prop}
    (q : Quotient s)
    (h : (a : α) → motive (Quotient.mk s a))
    : motive q 
Arguments: {α : Sort u} {s : Setoid α} {motive : Quotient s → Prop} (q : Quotient s) (h : ∀ (a : α), motive (Quotient.mk s a))
Goal: motive q
-- Quotient.exists_rep
theorem exists_rep {α : Sort u} {s : Setoid α} (q : Quotient s) : Exists (fun (a : α) => Quotient.mk s a = q) 
Arguments: {α : Sort u} {s : Setoid α} (q : Quotient s)
Goal: Exists fun a => Quotient.mk s a = q
-- Quotient.ind₂
@[elab_as_elim]
protected theorem ind₂
    {motive : Quotient s₁ → Quotient s₂ → Prop}
    (h : (a : α) → (b : β) → motive (Quotient.mk s₁ a) (Quotient.mk s₂ b))
    (q₁ : Quotient s₁)
    (q₂ : Quotient s₂)
    : motive q₁ q₂ 
Arguments: {α : Sort uA} {β : Sort uB} {s₁ : Setoid α} {s₂ : Setoid β} {motive : Quotient s₁ → Quotient s₂ → Prop} (h : ∀ (a : α) (b : β), motive (Quotient.mk s₁ a) (Quotient.mk s₂ b)) (q₁ : Quotient s₁) (q₂ : Quotient s₂)
Goal: motive q₁ q₂
-- Quotient.inductionOn₂
@[elab_as_elim]
protected theorem inductionOn₂
    {motive : Quotient s₁ → Quotient s₂ → Prop}
    (q₁ : Quotient s₁)
    (q₂ : Quotient s₂)
    (h : (a : α) → (b : β) → motive (Quotient.mk s₁ a) (Quotient.mk s₂ b))
    : motive q₁ q₂ 
Arguments: {α : Sort uA} {β : Sort uB} {s₁ : Setoid α} {s₂ : Setoid β} {motive : Quotient s₁ → Quotient s₂ → Prop} (q₁ : Quotient s₁) (q₂ : Quotient s₂) (h : ∀ (a : α) (b : β), motive (Quotient.mk s₁ a) (Quotient.mk s₂ b))
Goal: motive q₁ q₂
-- Quotient.inductionOn₃
@[elab_as_elim]
protected theorem inductionOn₃
    {s₃ : Setoid φ}
    {motive : Quotient s₁ → Quotient s₂ → Quotient s₃ → Prop}
    (q₁ : Quotient s₁)
    (q₂ : Quotient s₂)
    (q₃ : Quotient s₃)
    (h : (a : α) → (b : β) → (c : φ) → motive (Quotient.mk s₁ a) (Quotient.mk s₂ b) (Quotient.mk s₃ c))
    : motive q₁ q₂ q₃ 
Arguments: {α : Sort uA} {β : Sort uB} {φ : Sort uC} {s₁ : Setoid α} {s₂ : Setoid β} {s₃ : Setoid φ} {motive : Quotient s₁ → Quotient s₂ → Quotient s₃ → Prop} (q₁ : Quotient s₁) (q₂ : Quotient s₂) (q₃ : Quotient s₃) (h : ∀ (a : α) (b : β) (c : φ), motive (Quotient.mk s₁ a) (Quotient.mk s₂ b) (Quotient.mk s₃ c))
Goal: motive q₁ q₂ q₃
-- _private.«.lake».packages.lean4.src.lean.Init.Core.0.Quotient.rel.refl
private theorem rel.refl {s : Setoid α} (q : Quotient s) : rel q q 
Arguments: {α : Sort u} {s : Setoid α} (q : Quotient s)
Goal: Quotient.rel q q
-- _private.«.lake».packages.lean4.src.lean.Init.Core.0.Quotient.rel_of_eq
private theorem rel_of_eq {s : Setoid α} {q₁ q₂ : Quotient s} : q₁ = q₂ → rel q₁ q₂ 
Arguments: {α : Sort u} {s : Setoid α} {q₁ q₂ : Quotient s}
Goal: q₁ = q₂ → Quotient.rel q₁ q₂
-- Quotient.exact
theorem exact {s : Setoid α} {a b : α} : Quotient.mk s a = Quotient.mk s b → a ≈ b 
Arguments: {α : Sort u} {s : Setoid α} {a b : α}
Goal: Quotient.mk s a = Quotient.mk s b → a ≈ b
-- funext
theorem funext {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}
    (h : ∀ x, f x = g x) : f = g 
Arguments: {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x} (h : ∀ (x : α), f x = g x)
Goal: f = g
-- Squash.ind
theorem Squash.ind {α : Type u} {motive : Squash α → Prop} (h : ∀ (a : α), motive (Squash.mk a)) : ∀ (q : Squash α), motive q 
Arguments: {α : Type u} {motive : Squash α → Prop} (h : ∀ (a : α), motive (Squash.mk a)) (q : Squash α)
Goal: motive q
-- Antisymm.antisymm
class Antisymm {α : Sort u} (r : α → α → Prop) where
    antisymm {a b : α} : r a b → r b a → a = b
Arguments: {α : Sort u} {r : α → α → Prop} [self : Antisymm r] {a b : α}
Goal: r a b → r b a → a = b
-- ge_iff_le
@[simp] theorem ge_iff_le [LE α] {x y : α} : x ≥ y ↔ y ≤ x 
Arguments: {α : Type u} [LE α] {x y : α}
Goal: x ≥ y ↔ y ≤ x
-- gt_iff_lt
@[simp] theorem gt_iff_lt [LT α] {x y : α} : x > y ↔ y < x 
Arguments: {α : Type u} [LT α] {x y : α}
Goal: x > y ↔ y < x
-- le_of_eq_of_le
theorem le_of_eq_of_le {a b c : α} [LE α] (h₁ : a = b) (h₂ : b ≤ c) : a ≤ c 
Arguments: {α : Type u} {a b c : α} [LE α] (h₁ : a = b) (h₂ : b ≤ c)
Goal: a ≤ c
-- le_of_le_of_eq
theorem le_of_le_of_eq {a b c : α} [LE α] (h₁ : a ≤ b) (h₂ : b = c) : a ≤ c 
Arguments: {α : Type u} {a b c : α} [LE α] (h₁ : a ≤ b) (h₂ : b = c)
Goal: a ≤ c
-- lt_of_eq_of_lt
theorem lt_of_eq_of_lt {a b c : α} [LT α] (h₁ : a = b) (h₂ : b < c) : a < c 
Arguments: {α : Type u} {a b c : α} [LT α] (h₁ : a = b) (h₂ : b < c)
Goal: a < c
-- lt_of_lt_of_eq
theorem lt_of_lt_of_eq {a b c : α} [LT α] (h₁ : a < b) (h₂ : b = c) : a < c 
Arguments: {α : Type u} {a b c : α} [LT α] (h₁ : a < b) (h₂ : b = c)
Goal: a < c
-- Std.Associative.assoc
class Associative (op : α → α → α) : Prop where
    assoc : (a b c : α) → op (op a b) c = op a (op b c)
Arguments: {α : Sort u} {op : α → α → α} [self : Std.Associative op] (a b c : α)
Goal: op (op a b) c = op a (op b c)
-- Std.Commutative.comm
class Commutative (op : α → α → α) : Prop where
    comm : (a b : α) → op a b = op b a
Arguments: {α : Sort u} {op : α → α → α} [self : Std.Commutative op] (a b : α)
Goal: op a b = op b a
-- Std.IdempotentOp.idempotent
class IdempotentOp (op : α → α → α) : Prop where
    idempotent : (x : α) → op x x = x
Arguments: {α : Sort u} {op : α → α → α} [self : Std.IdempotentOp op] (x : α)
Goal: op x x = x
-- Std.LawfulLeftIdentity.left_id
class LawfulLeftIdentity (op : α → β → β) (o : outParam α) extends LeftIdentity op o : Prop where
    left_id : ∀ a, op o a = a
Arguments: {α : Sort u} {β : Sort u_1} {op : α → β → β} {o : outParam α} [self : Std.LawfulLeftIdentity op o] (a : β)
Goal: op o a = a
-- Std.LawfulRightIdentity.right_id
class LawfulRightIdentity (op : α → β → α) (o : outParam β) extends RightIdentity op o : Prop where
    right_id : ∀ a, op a o = a
Arguments: {α : Sort u} {β : Sort u_1} {op : α → β → α} {o : outParam β} [self : Std.LawfulRightIdentity op o] (a : α)
Goal: op a o = a
-- Lean.Grind.iff_eq
@[grind_norm] theorem iff_eq (p q : Prop) : (p ↔ q) = (p = q) 
Arguments: (p q : Prop)
Goal: (p ↔ q) = (p = q)
-- Lean.Grind.eq_true_eq
@[grind_norm] theorem eq_true_eq (p : Prop) : (p = True) = p 
Arguments: (p : Prop)
Goal: (p = True) = p
-- Lean.Grind.eq_false_eq
@[grind_norm] theorem eq_false_eq (p : Prop) : (p = False) = ¬p 
Arguments: (p : Prop)
Goal: (p = False) = ¬p
-- Lean.Grind.not_eq_prop
@[grind_norm] theorem not_eq_prop (p q : Prop) : (¬(p = q)) = (p = ¬q) 
Arguments: (p q : Prop)
Goal: (¬p = q) = (p = ¬q)
-- Lean.Grind.imp_eq
@[grind_norm] theorem imp_eq (p q : Prop) : (p → q) = (¬ p ∨ q) 
Arguments: (p q : Prop)
Goal: (p → q) = (¬p ∨ q)
-- Lean.Grind.not_and
@[grind_norm↓] theorem not_and (p q : Prop) : (¬(p ∧ q)) = (¬p ∨ ¬q) 
Arguments: (p q : Prop)
Goal: (¬(p ∧ q)) = (¬p ∨ ¬q)
-- Lean.Grind.not_ite
@[grind_norm↓] theorem not_ite {_ : Decidable p} (q r : Prop) : (¬ite p q r) = ite p (¬q) (¬r) 
Arguments: {p : Prop}
Goal: ∀ {x : Decidable p} (q r : Prop), (¬if p then q else r) = if p then ¬q else ¬r
-- Lean.Grind.not_forall
@[grind_norm↓] theorem not_forall (p : α → Prop) : (¬∀ x, p x) = ∃ x, ¬p x 
Arguments: {α : Sort u_1} (p : α → Prop)
Goal: (¬∀ (x : α), p x) = ∃ x, ¬p x
-- Lean.Grind.not_exists
@[grind_norm↓] theorem not_exists (p : α → Prop) : (¬∃ x, p x) = ∀ x, ¬p x 
Arguments: {α : Sort u_1} (p : α → Prop)
Goal: (¬∃ x, p x) = ∀ (x : α), ¬p x
-- Lean.Grind.cond_eq_ite
@[grind_norm] theorem cond_eq_ite (c : Bool) (a b : α) : cond c a b = ite c a b 
Arguments: {α : Type u_1} (c : Bool) (a b : α)
Goal: (bif c then a else b) = if c = true then a else b
-- Lean.Grind.Nat.lt_eq
@[grind_norm] theorem Nat.lt_eq (a b : Nat) : (a < b) = (a + 1 ≤ b) 
Arguments: (a b : Nat)
Goal: (a < b) = (a + 1 ≤ b)
-- Lean.Grind.Int.lt_eq
@[grind_norm] theorem Int.lt_eq (a b : Int) : (a < b) = (a + 1 ≤ b) 
Arguments: (a b : Int)
Goal: (a < b) = (a + 1 ≤ b)
-- outOfBounds_eq_default
theorem outOfBounds_eq_default [Inhabited α] : (outOfBounds : α) = default 
Arguments: {α : Type u_1} [Inhabited α]
Goal: outOfBounds = default
-- LawfulGetElem.getElem!_def
class LawfulGetElem (cont : Type u) (idx : Type v) (elem : outParam (Type w))
   (dom : outParam (cont → idx → Prop)) [ge : GetElem? cont idx elem dom] : Prop where

  getElem?_def (c : cont) (i : idx) [Decidable (dom c i)] :
      c[i]? = if h : dom c i then some (c[i]'h) else none := by
    intros
    try simp only [getElem?] <;> congr
  getElem!_def [Inhabited elem] (c : cont) (i : idx) :
      c[i]! = match c[i]? with | some e => e | none => default := by
    intros
    simp only [getElem!, getElem?, outOfBounds_eq_default]
Arguments: {cont : Type u} {idx : Type v} {elem : outParam (Type w)} {dom : outParam (cont → idx → Prop)} [ge : GetElem? cont idx elem dom] [self : LawfulGetElem cont idx elem dom] [Inhabited elem] (c : cont) (i : idx)
Goal: getElem! c i =
  match getElem? c i with
  | some e => e
  | none => default
-- LawfulGetElem.getElem?_def
class LawfulGetElem (cont : Type u) (idx : Type v) (elem : outParam (Type w))
   (dom : outParam (cont → idx → Prop)) [ge : GetElem? cont idx elem dom] : Prop where

  getElem?_def (c : cont) (i : idx) [Decidable (dom c i)] :
      c[i]? = if h : dom c i then some (c[i]'h) else none := by
    intros
    try simp only [getElem?] <;> congr
  getElem!_def [Inhabited elem] (c : cont) (i : idx) :
      c[i]! = match c[i]? with | some e => e | none => default := by
    intros
    simp only [getElem!, getElem?, outOfBounds_eq_default]
Arguments: {cont : Type u} {idx : Type v} {elem : outParam (Type w)} {dom : outParam (cont → idx → Prop)} [ge : GetElem? cont idx elem dom] [self : LawfulGetElem cont idx elem dom] (c : cont) (i : idx) [Decidable (dom c i)]
Goal: getElem? c i = if h : dom c i then some (getElem c i h) else none
-- getElem?_pos
theorem getElem?_pos [GetElem? cont idx elem dom] [LawfulGetElem cont idx elem dom]
    (c : cont) (i : idx) (h : dom c i) [Decidable (dom c i)] : c[i]? = some (c[i]'h) 
Arguments: {cont : Type u_1} {idx : Type u_2} {elem : Type u_3} {dom : cont → idx → Prop} [GetElem? cont idx elem dom] [LawfulGetElem cont idx elem dom] (c : cont) (i : idx) (h : dom c i) [Decidable (dom c i)]
Goal: getElem? c i = some (getElem c i h)
-- getElem?_neg
theorem getElem?_neg [GetElem? cont idx elem dom] [LawfulGetElem cont idx elem dom]
    (c : cont) (i : idx) (h : ¬dom c i) [Decidable (dom c i)] : c[i]? = none 
Arguments: {cont : Type u_1} {idx : Type u_2} {elem : Type u_3} {dom : cont → idx → Prop} [GetElem? cont idx elem dom] [LawfulGetElem cont idx elem dom] (c : cont) (i : idx) (h : ¬dom c i) [Decidable (dom c i)]
Goal: getElem? c i = none
-- getElem!_pos
theorem getElem!_pos [GetElem? cont idx elem dom] [LawfulGetElem cont idx elem dom]
    [Inhabited elem] (c : cont) (i : idx) (h : dom c i) [Decidable (dom c i)] :
    c[i]! = c[i]'h 
Arguments: {cont : Type u_1} {idx : Type u_2} {elem : Type u_3} {dom : cont → idx → Prop} [GetElem? cont idx elem dom] [LawfulGetElem cont idx elem dom] [Inhabited elem] (c : cont) (i : idx) (h : dom c i) [Decidable (dom c i)]
Goal: getElem! c i = getElem c i h
-- getElem!_neg
theorem getElem!_neg [GetElem? cont idx elem dom] [LawfulGetElem cont idx elem dom]
    [Inhabited elem] (c : cont) (i : idx) (h : ¬dom c i) [Decidable (dom c i)] : c[i]! = default 
Arguments: {cont : Type u_1} {idx : Type u_2} {elem : Type u_3} {dom : cont → idx → Prop} [GetElem? cont idx elem dom] [LawfulGetElem cont idx elem dom] [Inhabited elem] (c : cont) (i : idx) (h : ¬dom c i) [Decidable (dom c i)]
Goal: getElem! c i = default
-- Fin.getElem_fin
@[simp] theorem getElem_fin [GetElem? Cont Nat Elem Dom] (a : Cont) (i : Fin n) (h : Dom a i) :
    a[i] = a[i.1] 
Arguments: {Cont : Type u_1} {Elem : Type u_2} {Dom : Cont → Nat → Prop} {n : Nat} [GetElem? Cont Nat Elem Dom] (a : Cont) (i : Fin n) (h : Dom a ↑i)
Goal: getElem a i h = getElem a (↑i) h
-- Fin.getElem?_fin
@[simp] theorem getElem?_fin [h : GetElem? Cont Nat Elem Dom] (a : Cont) (i : Fin n)
    [Decidable (Dom a i)] : a[i]? = a[i.1]? 
Arguments: {Cont : Type u_1} {Elem : Type u_2} {Dom : Cont → Nat → Prop} {n : Nat} [h : GetElem? Cont Nat Elem Dom] (a : Cont) (i : Fin n) [Decidable (Dom a ↑i)]
Goal: getElem? a i = getElem? a ↑i
-- Fin.getElem!_fin
@[simp] theorem getElem!_fin [GetElem? Cont Nat Elem Dom] (a : Cont) (i : Fin n)
    [Decidable (Dom a i)] [Inhabited Elem] : a[i]! = a[i.1]! 
Arguments: {Cont : Type u_1} {Elem : Type u_2} {Dom : Cont → Nat → Prop} {n : Nat} [GetElem? Cont Nat Elem Dom] (a : Cont) (i : Fin n) [Decidable (Dom a ↑i)] [Inhabited Elem]
Goal: getElem! a i = getElem! a ↑i
-- List.getElem_cons_zero
@[simp] theorem getElem_cons_zero (a : α) (as : List α) (h : 0 < (a :: as).length) : getElem (a :: as) 0 h = a 
Arguments: {α : Type u_1} (a : α) (as : List α) (h : 0 < (a :: as).length)
Goal: getElem (a :: as) 0 h = a
-- List.getElem_cons_succ
@[simp] theorem getElem_cons_succ (a : α) (as : List α) (i : Nat) (h : i + 1 < (a :: as).length) : getElem (a :: as) (i+1) h = getElem as i (Nat.lt_of_succ_lt_succ h) 
Arguments: {α : Type u_1} (a : α) (as : List α) (i : Nat) (h : i + 1 < (a :: as).length)
Goal: getElem (a :: as) (i + 1) h = getElem as i ⋯
-- List.get_drop_eq_drop
theorem get_drop_eq_drop (as : List α) (i : Nat) (h : i < as.length) : as[i] :: as.drop (i+1) = as.drop i 
Arguments: {α : Type u_1} (as : List α) (i : Nat) (h : i < as.length)
Goal: getElem as i h :: List.drop (i + 1) as = List.drop i as
-- Lean.Omega.Constraint.translate_sat
theorem translate_sat : {c : Constraint} → {v : Int} → sat c v → sat (c.translate t) (v + t) 
Arguments: {t : Int} {c : Lean.Omega.Constraint} {v : Int}
Goal: c.sat v = true → (c.translate t).sat (v + t) = true
-- Lean.Omega.Constraint.neg_sat
theorem neg_sat : {c : Constraint} → {v : Int} → sat c v → sat (c.neg) (-v) 
Arguments: {c : Lean.Omega.Constraint} {v : Int}
Goal: c.sat v = true → c.neg.sat (-v) = true
-- Lean.Omega.Constraint.trivial_say
@[simp] theorem trivial_say : trivial.sat t 
Arguments: {t : Int}
Goal: Lean.Omega.Constraint.trivial.sat t = true
-- Lean.Omega.Constraint.exact_sat
@[simp] theorem exact_sat (r : Int) (t : Int) : (exact r).sat t = decide (r = t) 
Arguments: (r t : Int)
Goal: (Lean.Omega.Constraint.exact r).sat t = decide (r = t)
-- Lean.Omega.Constraint.not_sat_of_isImpossible
theorem not_sat_of_isImpossible (h : isImpossible c) {t} : ¬ c.sat t 
Arguments: {c : Lean.Omega.Constraint} (h : c.isImpossible = true) {t : Int}
Goal: ¬c.sat t = true
-- Lean.Omega.Constraint.scale_sat
theorem scale_sat {c : Constraint} (k) (w : c.sat t) : (scale k c).sat (k * t) 
Arguments: {t : Int} {c : Lean.Omega.Constraint} (k : Int) (w : c.sat t = true)
Goal: (Lean.Omega.Constraint.scale k c).sat (k * t) = true
-- Lean.Omega.Constraint.add_sat
theorem add_sat (w₁ : c₁.sat x₁) (w₂ : c₂.sat x₂) : (add c₁ c₂).sat (x₁ + x₂) 
Arguments: {c₁ c₂ : Lean.Omega.Constraint} {x₁ x₂ : Int} (w₁ : c₁.sat x₁ = true) (w₂ : c₂.sat x₂ = true)
Goal: (c₁.add c₂).sat (x₁ + x₂) = true
-- Lean.Omega.Constraint.combo_sat
theorem combo_sat (a) (w₁ : c₁.sat x₁) (b) (w₂ : c₂.sat x₂) :
    (combo a c₁ b c₂).sat (a * x₁ + b * x₂) 
Arguments: {c₁ c₂ : Lean.Omega.Constraint} {x₁ x₂ : Int} (a : Int) (w₁ : c₁.sat x₁ = true) (b : Int) (w₂ : c₂.sat x₂ = true)
Goal: (Lean.Omega.Constraint.combo a c₁ b c₂).sat (a * x₁ + b * x₂) = true
-- Lean.Omega.Constraint.combine_sat
theorem combine_sat : (c : Constraint) → (c' : Constraint) → (t : Int) →
    (c.combine c').sat t = (c.sat t ∧ c'.sat t) 
Arguments: (c c' : Lean.Omega.Constraint) (t : Int)
Goal: ((c.combine c').sat t = true) = (c.sat t = true ∧ c'.sat t = true)
-- Lean.Omega.Constraint.div_sat
theorem div_sat (c : Constraint) (t : Int) (k : Nat) (n : k ≠ 0) (h : (k : Int) ∣ t) (w : c.sat t) :
    (c.div k).sat (t / k) 
Arguments: (c : Lean.Omega.Constraint) (t : Int) (k : Nat) (n : k ≠ 0) (h : ↑k ∣ t) (w : c.sat t = true)
Goal: (c.div k).sat (t / ↑k) = true
-- Lean.Omega.Constraint.combine_sat'
theorem combine_sat' {s t : Constraint} {x y} (ws : s.sat' x y) (wt : t.sat' x y) :
    (s.combine t).sat' x y 
Arguments: {s t : Lean.Omega.Constraint} {x y : Lean.Omega.Coeffs} (ws : s.sat' x y = true) (wt : t.sat' x y = true)
Goal: (s.combine t).sat' x y = true
-- Lean.Omega.Constraint.div_sat'
theorem div_sat' {c : Constraint} {x y} (h : Coeffs.gcd x ≠ 0) (w : c.sat (Coeffs.dot x y)) :
    (c.div (Coeffs.gcd x)).sat' (Coeffs.sdiv x (Coeffs.gcd x)) y 
Arguments: {c : Lean.Omega.Constraint} {x y : Lean.Omega.Coeffs} (h : x.gcd ≠ 0) (w : c.sat (x.dot y) = true)
Goal: (c.div x.gcd).sat' (x.sdiv ↑x.gcd) y = true
-- Lean.Omega.Constraint.not_sat'_of_isImpossible
theorem not_sat'_of_isImpossible (h : isImpossible c) {x y} : ¬ c.sat' x y 
Arguments: {c : Lean.Omega.Constraint} (h : c.isImpossible = true) {x y : Lean.Omega.Coeffs}
Goal: ¬c.sat' x y = true
-- Lean.Omega.Constraint.addInequality_sat
theorem addInequality_sat (w : c + Coeffs.dot x y ≥ 0) :
    Constraint.sat' { lowerBound := some (-c), upperBound := none } x y 
Arguments: {c : Int} {x y : Lean.Omega.Coeffs} (w : c + x.dot y ≥ 0)
Goal: { lowerBound := some (-c), upperBound := none }.sat' x y = true
-- Lean.Omega.Constraint.addEquality_sat
theorem addEquality_sat (w : c + Coeffs.dot x y = 0) :
    Constraint.sat' { lowerBound := some (-c), upperBound := some (-c) } x y 
Arguments: {c : Int} {x y : Lean.Omega.Coeffs} (w : c + x.dot y = 0)
Goal: { lowerBound := some (-c), upperBound := some (-c) }.sat' x y = true
-- Lean.Omega.normalize?_eq_some
theorem normalize?_eq_some (w : normalize? (s, x) = some (s', x')) :
    normalizeConstraint s x = s' ∧ normalizeCoeffs s x = x' 
Arguments: {s : Lean.Omega.Constraint} {x : Lean.Omega.Coeffs} {s' : Lean.Omega.Constraint} {x' : Lean.Omega.Coeffs} (w : Lean.Omega.normalize? (s, x) = some (s', x'))
Goal: Lean.Omega.normalizeConstraint s x = s' ∧ Lean.Omega.normalizeCoeffs s x = x'
-- Lean.Omega.normalize_sat
theorem normalize_sat {s x v} (w : s.sat' x v) :
    (normalizeConstraint s x).sat' (normalizeCoeffs s x) v 
Arguments: {s : Lean.Omega.Constraint} {x v : Lean.Omega.Coeffs} (w : s.sat' x v = true)
Goal: (Lean.Omega.normalizeConstraint s x).sat' (Lean.Omega.normalizeCoeffs s x) v = true
-- Lean.Omega.positivize?_eq_some
theorem positivize?_eq_some (w : positivize? (s, x) = some (s', x')) :
    positivizeConstraint s x = s' ∧ positivizeCoeffs s x = x' 
Arguments: {s : Lean.Omega.Constraint} {x : Lean.Omega.Coeffs} {s' : Lean.Omega.Constraint} {x' : Lean.Omega.Coeffs} (w : Lean.Omega.positivize? (s, x) = some (s', x'))
Goal: Lean.Omega.positivizeConstraint s x = s' ∧ Lean.Omega.positivizeCoeffs s x = x'
-- Lean.Omega.positivize_sat
theorem positivize_sat {s x v} (w : s.sat' x v) :
    (positivizeConstraint s x).sat' (positivizeCoeffs s x) v 
Arguments: {s : Lean.Omega.Constraint} {x v : Lean.Omega.Coeffs} (w : s.sat' x v = true)
Goal: (Lean.Omega.positivizeConstraint s x).sat' (Lean.Omega.positivizeCoeffs s x) v = true
-- Lean.Omega.tidy_sat
theorem tidy_sat {s x v} (w : s.sat' x v) : (tidyConstraint s x).sat' (tidyCoeffs s x) v 
Arguments: {s : Lean.Omega.Constraint} {x v : Lean.Omega.Coeffs} (w : s.sat' x v = true)
Goal: (Lean.Omega.tidyConstraint s x).sat' (Lean.Omega.tidyCoeffs s x) v = true
-- Lean.Omega.combo_sat'
theorem combo_sat' (s t : Constraint)
    (a : Int) (x : Coeffs) (b : Int) (y : Coeffs) (v : Coeffs)
    (wx : s.sat' x v) (wy : t.sat' y v) :
    (Constraint.combo a s b t).sat' (Coeffs.combo a x b y) v 
Arguments: (s t : Lean.Omega.Constraint) (a : Int) (x : Lean.Omega.Coeffs) (b : Int) (y v : Lean.Omega.Coeffs) (wx : s.sat' x v = true) (wy : t.sat' y v = true)
Goal: (Lean.Omega.Constraint.combo a s b t).sat' (Lean.Omega.Coeffs.combo a x b y) v = true
-- Lean.Omega.bmod_sat
theorem bmod_sat (m : Nat) (r : Int) (i : Nat) (x v : Coeffs)
    (h : x.length ≤ i)  -- during proof reconstruction this will be by `decide`
    (p : Coeffs.get v i = bmod_div_term m x v) -- and this will be by `rfl`
    (w : (Constraint.exact r).sat' x v) :
    (Constraint.exact (Int.bmod r m)).sat' (bmod_coeffs m i x) v 
Arguments: (m : Nat) (r : Int) (i : Nat) (x v : Lean.Omega.Coeffs) (h : x.length ≤ i) (p : v.get i = Lean.Omega.bmod_div_term m x v) (w : (Lean.Omega.Constraint.exact r).sat' x v = true)
Goal: (Lean.Omega.Constraint.exact (r.bmod m)).sat' (Lean.Omega.bmod_coeffs m i x) v = true
-- Fin.sizeOf
@[simp] protected theorem Fin.sizeOf (a : Fin n) : sizeOf a = a.val + 1 
Arguments: {n : Nat} (a : Fin n)
Goal: sizeOf a = ↑a + 1
-- UInt8.sizeOf
@[simp] protected theorem UInt8.sizeOf (a : UInt8) : sizeOf a = a.toNat + 2 
Arguments: (a : UInt8)
Goal: sizeOf a = a.toNat + 2
-- UInt16.sizeOf
@[simp] protected theorem UInt16.sizeOf (a : UInt16) : sizeOf a = a.toNat + 2 
Arguments: (a : UInt16)
Goal: sizeOf a = a.toNat + 2
-- UInt32.sizeOf
@[simp] protected theorem UInt32.sizeOf (a : UInt32) : sizeOf a = a.toNat + 2 
Arguments: (a : UInt32)
Goal: sizeOf a = a.toNat + 2
-- UInt64.sizeOf
@[simp] protected theorem UInt64.sizeOf (a : UInt64) : sizeOf a = a.toNat + 2 
Arguments: (a : UInt64)
Goal: sizeOf a = a.toNat + 2
-- USize.sizeOf
@[simp] protected theorem USize.sizeOf (a : USize) : sizeOf a = a.toNat + 2 
Arguments: (a : USize)
Goal: sizeOf a = a.toNat + 2
-- Char.sizeOf
@[simp] protected theorem Char.sizeOf (a : Char) : sizeOf a = a.toNat + 3 
Arguments: (a : Char)
Goal: sizeOf a = a.toNat + 3
-- Subtype.sizeOf
@[simp] protected theorem Subtype.sizeOf {α : Sort u_1} {p : α → Prop} (s : Subtype p) : sizeOf s = sizeOf s.val + 1 
Arguments: {α : Sort u_1} {p : α → Prop} (s : Subtype p)
Goal: sizeOf s = sizeOf s.val + 1
-- if_true
@[simp] theorem if_true {_ : Decidable True} (t e : α) : ite True t e = t 
Arguments: {α : Sort u_1}
Goal: ∀ {x : Decidable True} (t e : α), (if True then t else e) = t
-- if_false
@[simp] theorem if_false {_ : Decidable False} (t e : α) : ite False t e = e 
Arguments: {α : Sort u_1}
Goal: ∀ {x : Decidable False} (t e : α), (if False then t else e) = e
-- ite_id
theorem ite_id [Decidable c] {α} (t : α) : (if c then t else t) = t 
Arguments: {c : Prop} [Decidable c] {α : Sort u_1} (t : α)
Goal: (if c then t else t) = t
-- apply_dite
theorem apply_dite (f : α → β) (P : Prop) [Decidable P] (x : P → α) (y : ¬P → α) :
    f (dite P x y) = dite P (fun h => f (x h)) (fun h => f (y h)) 
Arguments: {α : Sort u_1} {β : Sort u_2} (f : α → β) (P : Prop) [Decidable P] (x : P → α) (y : ¬P → α)
Goal: f (dite P x y) = if h : P then f (x h) else f (y h)
-- apply_ite
theorem apply_ite (f : α → β) (P : Prop) [Decidable P] (x y : α) :
    f (ite P x y) = ite P (f x) (f y) 
Arguments: {α : Sort u_1} {β : Sort u_2} (f : α → β) (P : Prop) [Decidable P] (x y : α)
Goal: f (if P then x else y) = if P then f x else f y
-- dite_eq_left_iff
@[simp] theorem dite_eq_left_iff {P : Prop} [Decidable P] {B : ¬ P → α} :
    dite P (fun _ => a) B = a ↔ ∀ h, B h = a 
Arguments: {α : Sort u_1} {a : α} {P : Prop} [Decidable P] {B : ¬P → α}
Goal: dite P (fun x => a) B = a ↔ ∀ (h : ¬P), B h = a
-- dite_eq_right_iff
@[simp] theorem dite_eq_right_iff {P : Prop} [Decidable P] {A : P → α} :
    (dite P A fun _ => b) = b ↔ ∀ h, A h = b 
Arguments: {α : Sort u_1} {b : α} {P : Prop} [Decidable P] {A : P → α}
Goal: (dite P A fun x => b) = b ↔ ∀ (h : P), A h = b
-- ite_eq_left_iff
@[simp] theorem ite_eq_left_iff {P : Prop} [Decidable P] : ite P a b = a ↔ ¬P → b = a 
Goal: ∀ {α : Sort u_1} {a b : α} {P : Prop} [inst : Decidable P], (if P then a else b) = a ↔ ¬P → b = a
-- ite_eq_right_iff
@[simp] theorem ite_eq_right_iff {P : Prop} [Decidable P] : ite P a b = b ↔ P → a = b 
Goal: ∀ {α : Sort u_1} {a b : α} {P : Prop} [inst : Decidable P], (if P then a else b) = b ↔ P → a = b
-- dite_eq_ite
@[simp] theorem dite_eq_ite [Decidable P] : (dite P (fun _ => a) fun _ => b) = ite P a b 
Arguments: {P : Prop}
Goal: ∀ {α : Sort u_1} {a b : α} [inst : Decidable P], (if x : P then a else b) = if P then a else b
-- ite_some_none_eq_none
theorem ite_some_none_eq_none [Decidable P] :
    (if P then some x else none) = none ↔ ¬ P 
Arguments: {P : Prop}
Goal: ∀ {α : Type u_1} {x : α} [inst : Decidable P], (if P then some x else none) = none ↔ ¬P
-- ite_some_none_eq_some
@[simp] theorem ite_some_none_eq_some [Decidable P] :
    (if P then some x else none) = some y ↔ P ∧ x = y 
Arguments: {P : Prop}
Goal: ∀ {α : Type u_1} {x y : α} [inst : Decidable P], (if P then some x else none) = some y ↔ P ∧ x = y