ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Bool.or_left_comm
theorem or_left_comm : ∀ (x y z : Bool), (x || (y || z)) = (y || (x || z)) 
Arguments: (x y z : Bool)
Goal: (x || (y || z)) = (y || (x || z))
-- Bool.or_right_comm
theorem or_right_comm : ∀ (x y z : Bool), ((x || y) || z) = ((x || z) || y) 
Arguments: (x y z : Bool)
Goal: (x || y || z) = (x || z || y)
-- Bool.and_or_distrib_left
theorem and_or_distrib_left  : ∀ (x y z : Bool), (x && (y || z)) = (x && y || x && z) 
Arguments: (x y z : Bool)
Goal: (x && (y || z)) = (x && y || x && z)
-- Bool.and_or_distrib_right
theorem and_or_distrib_right : ∀ (x y z : Bool), ((x || y) && z) = (x && z || y && z) 
Arguments: (x y z : Bool)
Goal: ((x || y) && z) = (x && z || y && z)
-- Bool.or_and_distrib_left
theorem or_and_distrib_left  : ∀ (x y z : Bool), (x || y && z) = ((x || y) && (x || z)) 
Arguments: (x y z : Bool)
Goal: (x || y && z) = ((x || y) && (x || z))
-- Bool.or_and_distrib_right
theorem or_and_distrib_right : ∀ (x y z : Bool), (x && y || z) = ((x || z) && (y || z)) 
Arguments: (x y z : Bool)
Goal: (x && y || z) = ((x || z) && (y || z))
-- Bool.and_xor_distrib_left
theorem and_xor_distrib_left : ∀ (x y z : Bool), (x && xor y z) = xor (x && y) (x && z) 
Arguments: (x y z : Bool)
Goal: (x && xor y z) = xor (x && y) (x && z)
-- Bool.and_xor_distrib_right
theorem and_xor_distrib_right : ∀ (x y z : Bool), (xor x y && z) = xor (x && z) (y && z) 
Arguments: (x y z : Bool)
Goal: (xor x y && z) = xor (x && z) (y && z)
-- Bool.not_and
@[simp] theorem not_and : ∀ (x y : Bool), (!(x && y)) = (!x || !y) 
Arguments: (x y : Bool)
Goal: (!(x && y)) = (!x || !y)
-- Bool.not_or
@[simp] theorem not_or : ∀ (x y : Bool), (!(x || y)) = (!x && !y) 
Arguments: (x y : Bool)
Goal: (!(x || y)) = (!x && !y)
-- Bool.and_eq_true_iff
theorem and_eq_true_iff (x y : Bool) : (x && y) = true ↔ x = true ∧ y = true 
Arguments: (x y : Bool)
Goal: (x && y) = true ↔ x = true ∧ y = true
-- Bool.and_eq_false_iff
theorem and_eq_false_iff : ∀ (x y : Bool), (x && y) = false ↔ x = false ∨ y = false 
Arguments: (x y : Bool)
Goal: (x && y) = false ↔ x = false ∨ y = false
-- Bool.and_eq_false_imp
@[simp] theorem and_eq_false_imp : ∀ (x y : Bool), (x && y) = false ↔ (x = true → y = false) 
Arguments: (x y : Bool)
Goal: (x && y) = false ↔ x = true → y = false
-- Bool.or_eq_true_iff
@[simp] theorem or_eq_true_iff : ∀ (x y : Bool), (x || y) = true ↔ x = true ∨ y = true 
Arguments: (x y : Bool)
Goal: (x || y) = true ↔ x = true ∨ y = true
-- Bool.or_eq_false_iff
@[simp] theorem or_eq_false_iff : ∀ (x y : Bool), (x || y) = false ↔ x = false ∧ y = false 
Arguments: (x y : Bool)
Goal: (x || y) = false ↔ x = false ∧ y = false
-- Bool.false_eq_true
@[simp] theorem false_eq_true : (false = true) = False 
Goal: (false = true) = False
-- Bool.true_eq_false
@[simp] theorem true_eq_false : (true = false) = False 
Goal: (true = false) = False
-- Bool.false_eq
@[simp low] theorem false_eq (b : Bool) : (false = b) = (b = false) 
Arguments: (b : Bool)
Goal: (false = b) = (b = false)
-- Bool.true_eq
@[simp low] theorem true_eq (b : Bool) : (true = b) = (b = true) 
Arguments: (b : Bool)
Goal: (true = b) = (b = true)
-- Bool.true_beq
@[simp] theorem true_beq  : ∀b, (true  == b) =  b 
Arguments: (b : Bool)
Goal: (true == b) = b
-- Bool.false_beq
@[simp] theorem false_beq : ∀b, (false == b) = !b 
Arguments: (b : Bool)
Goal: (false == b) = !b
-- Bool.beq_true
@[simp] theorem beq_true  : ∀b, (b == true)  =  b 
Arguments: (b : Bool)
Goal: (b == true) = b
-- Bool.beq_false
@[simp] theorem beq_false : ∀b, (b == false) = !b 
Arguments: (b : Bool)
Goal: (b == false) = !b
-- Bool.true_bne
@[simp] theorem true_bne  : ∀(b : Bool), (true  != b) = !b 
Arguments: (b : Bool)
Goal: (true != b) = !b
-- Bool.false_bne
@[simp] theorem false_bne : ∀(b : Bool), (false != b) =  b 
Arguments: (b : Bool)
Goal: (false != b) = b
-- Bool.bne_true
@[simp] theorem bne_true  : ∀(b : Bool), (b != true)  = !b 
Arguments: (b : Bool)
Goal: (b != true) = !b
-- Bool.bne_false
@[simp] theorem bne_false : ∀(b : Bool), (b != false) =  b 
Arguments: (b : Bool)
Goal: (b != false) = b
-- Bool.not_beq_self
@[simp] theorem not_beq_self : ∀ (x : Bool), ((!x) == x) = false 
Arguments: (x : Bool)
Goal: ((!x) == x) = false
-- Bool.beq_not_self
@[simp] theorem beq_not_self : ∀ (x : Bool), (x   == !x) = false 
Arguments: (x : Bool)
Goal: (x == !x) = false
-- Bool.not_bne_self
@[simp] theorem not_bne_self : ∀ (x : Bool), ((!x) != x) = true 
Arguments: (x : Bool)
Goal: ((!x) != x) = true
-- Bool.bne_not_self
@[simp] theorem bne_not_self : ∀ (x : Bool), (x   != !x) = true 
Arguments: (x : Bool)
Goal: (x != !x) = true
-- Bool.not_eq_self
@[simp] theorem not_eq_self : ∀(b : Bool), ((!b) = b) ↔ False 
Arguments: (b : Bool)
Goal: (!b) = b ↔ False
-- Bool.eq_not_self
@[simp] theorem eq_not_self : ∀(b : Bool), (b = (!b)) ↔ False 
Arguments: (b : Bool)
Goal: b = !b ↔ False
-- Bool.beq_self_left
@[simp] theorem beq_self_left  : ∀(a b : Bool), (a == (a == b)) = b 
Arguments: (a b : Bool)
Goal: (a == (a == b)) = b
-- Bool.beq_self_right
@[simp] theorem beq_self_right : ∀(a b : Bool), ((a == b) == b) = a 
Arguments: (a b : Bool)
Goal: ((a == b) == b) = a
-- Bool.bne_self_left
@[simp] theorem bne_self_left  : ∀(a b : Bool), (a != (a != b)) = b 
Arguments: (a b : Bool)
Goal: (a != (a != b)) = b
-- Bool.bne_self_right
@[simp] theorem bne_self_right : ∀(a b : Bool), ((a != b) != b) = a 
Arguments: (a b : Bool)
Goal: ((a != b) != b) = a
-- Bool.not_bne_not
@[simp] theorem not_bne_not : ∀ (x y : Bool), ((!x) != (!y)) = (x != y) 
Arguments: (x y : Bool)
Goal: ((!x) != !y) = (x != y)
-- Bool.bne_assoc
@[simp] theorem bne_assoc : ∀ (x y z : Bool), ((x != y) != z) = (x != (y != z)) 
Arguments: (x y z : Bool)
Goal: ((x != y) != z) = (x != (y != z))
-- Bool.bne_left_inj
@[simp] theorem bne_left_inj  : ∀ (x y z : Bool), (x != y) = (x != z) ↔ y = z 
Arguments: (x y z : Bool)
Goal: (x != y) = (x != z) ↔ y = z
-- Bool.bne_right_inj
@[simp] theorem bne_right_inj : ∀ (x y z : Bool), (x != z) = (y != z) ↔ x = y 
Arguments: (x y z : Bool)
Goal: (x != z) = (y != z) ↔ x = y
-- Bool.eq_not_of_ne
theorem eq_not_of_ne : ∀ {x y : Bool}, x ≠ y → x = !y 
Arguments: {x y : Bool}
Goal: x ≠ y → x = !y
-- Bool.beq_eq_decide_eq
theorem beq_eq_decide_eq [BEq α] [LawfulBEq α] [DecidableEq α] (a b : α) :
    (a == b) = decide (a = b) 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] [DecidableEq α] (a b : α)
Goal: (a == b) = decide (a = b)
-- Bool.not_eq_not
@[simp] theorem not_eq_not : ∀ {a b : Bool}, ¬a = !b ↔ a = b 
Arguments: {a b : Bool}
Goal: ¬a = !b ↔ a = b
-- Bool.not_not_eq
@[simp] theorem not_not_eq : ∀ {a b : Bool}, ¬(!a) = b ↔ a = b 
Arguments: {a b : Bool}
Goal: ¬(!a) = b ↔ a = b
-- Bool.coe_iff_coe
@[simp] theorem coe_iff_coe : ∀(a b : Bool), (a ↔ b) ↔ a = b 
Arguments: (a b : Bool)
Goal: (a = true ↔ b = true) ↔ a = b
-- Bool.coe_true_iff_false
@[simp] theorem coe_true_iff_false  : ∀(a b : Bool), (a ↔ b = false) ↔ a = (!b) 
Arguments: (a b : Bool)
Goal: (a = true ↔ b = false) ↔ a = !b
-- Bool.coe_false_iff_true
@[simp] theorem coe_false_iff_true  : ∀(a b : Bool), (a = false ↔ b) ↔ (!a) = b 
Arguments: (a b : Bool)
Goal: (a = false ↔ b = true) ↔ (!a) = b
-- Bool.coe_false_iff_false
@[simp] theorem coe_false_iff_false : ∀(a b : Bool), (a = false ↔ b = false) ↔ (!a) = (!b) 
Arguments: (a b : Bool)
Goal: (a = false ↔ b = false) ↔ (!a) = !b
-- Bool.beq_comm
theorem beq_comm {α} [BEq α] [LawfulBEq α] {a b : α} : (a == b) = (b == a) 
Arguments: {α : Type u_1} [BEq α] [LawfulBEq α] {a b : α}
Goal: (a == b) = (b == a)
-- Bool.false_xor
theorem false_xor : ∀ (x : Bool), xor false x = x 
Arguments: (x : Bool)
Goal: xor false x = x
-- Bool.xor_false
theorem xor_false : ∀ (x : Bool), xor x false = x 
Arguments: (x : Bool)
Goal: xor x false = x
-- Bool.true_xor
theorem true_xor : ∀ (x : Bool), xor true x = !x 
Arguments: (x : Bool)
Goal: xor true x = !x
-- Bool.xor_true
theorem xor_true : ∀ (x : Bool), xor x true = !x 
Arguments: (x : Bool)
Goal: xor x true = !x
-- Bool.not_xor_self
theorem not_xor_self : ∀ (x : Bool), xor (!x) x = true 
Arguments: (x : Bool)
Goal: xor (!x) x = true
-- Bool.xor_not_self
theorem xor_not_self : ∀ (x : Bool), xor x (!x) = true 
Arguments: (x : Bool)
Goal: (xor x !x) = true
-- Bool.not_xor
theorem not_xor : ∀ (x y : Bool), xor (!x) y = !(xor x y) 
Arguments: (x y : Bool)
Goal: xor (!x) y = !xor x y
-- Bool.xor_not
theorem xor_not : ∀ (x y : Bool), xor x (!y) = !(xor x y) 
Arguments: (x y : Bool)
Goal: (xor x !y) = !xor x y
-- Bool.not_xor_not
theorem not_xor_not : ∀ (x y : Bool), xor (!x) (!y) = (xor x y) 
Arguments: (x y : Bool)
Goal: (xor (!x) !y) = xor x y
-- Bool.xor_self
theorem xor_self : ∀ (x : Bool), xor x x = false 
Arguments: (x : Bool)
Goal: xor x x = false
-- Bool.xor_comm
theorem xor_comm : ∀ (x y : Bool), xor x y = xor y x 
Arguments: (x y : Bool)
Goal: xor x y = xor y x
-- Bool.xor_left_comm
theorem xor_left_comm : ∀ (x y z : Bool), xor x (xor y z) = xor y (xor x z) 
Arguments: (x y z : Bool)
Goal: xor x (xor y z) = xor y (xor x z)
-- Bool.xor_right_comm
theorem xor_right_comm : ∀ (x y z : Bool), xor (xor x y) z = xor (xor x z) y 
Arguments: (x y z : Bool)
Goal: xor (xor x y) z = xor (xor x z) y
-- Bool.xor_assoc
theorem xor_assoc : ∀ (x y z : Bool), xor (xor x y) z = xor x (xor y z) 
Arguments: (x y z : Bool)
Goal: xor (xor x y) z = xor x (xor y z)
-- Bool.xor_left_inj
theorem xor_left_inj : ∀ (x y z : Bool), xor x y = xor x z ↔ y = z 
Arguments: (x y z : Bool)
Goal: xor x y = xor x z ↔ y = z
-- Bool.xor_right_inj
theorem xor_right_inj : ∀ (x y z : Bool), xor x z = xor y z ↔ x = y 
Arguments: (x y z : Bool)
Goal: xor x z = xor y z ↔ x = y
-- Bool.le_true
@[simp] protected theorem le_true : ∀ (x : Bool), x ≤ true 
Arguments: (x : Bool)
Goal: x ≤ true
-- Bool.false_le
@[simp] protected theorem false_le : ∀ (x : Bool), false ≤ x 
Arguments: (x : Bool)
Goal: false ≤ x
-- Bool.le_refl
@[simp] protected theorem le_refl : ∀ (x : Bool), x ≤ x 
Arguments: (x : Bool)
Goal: x ≤ x
-- Bool.lt_irrefl
@[simp] protected theorem lt_irrefl : ∀ (x : Bool), ¬ x < x 
Arguments: (x : Bool)
Goal: ¬x < x
-- Bool.le_trans
protected theorem le_trans : ∀ {x y z : Bool}, x ≤ y → y ≤ z → x ≤ z 
Arguments: {x y z : Bool}
Goal: x ≤ y → y ≤ z → x ≤ z
-- Bool.le_antisymm
protected theorem le_antisymm : ∀ {x y : Bool}, x ≤ y → y ≤ x → x = y 
Arguments: {x y : Bool}
Goal: x ≤ y → y ≤ x → x = y
-- Bool.le_total
protected theorem le_total : ∀ (x y : Bool), x ≤ y ∨ y ≤ x 
Arguments: (x y : Bool)
Goal: x ≤ y ∨ y ≤ x
-- Bool.lt_asymm
protected theorem lt_asymm : ∀ {x y : Bool}, x < y → ¬ y < x 
Arguments: {x y : Bool}
Goal: x < y → ¬y < x
-- Bool.lt_trans
protected theorem lt_trans : ∀ {x y z : Bool}, x < y → y < z → x < z 
Arguments: {x y z : Bool}
Goal: x < y → y < z → x < z
-- Bool.lt_iff_le_not_le
protected theorem lt_iff_le_not_le : ∀ {x y : Bool}, x < y ↔ x ≤ y ∧ ¬ y ≤ x 
Arguments: {x y : Bool}
Goal: x < y ↔ x ≤ y ∧ ¬y ≤ x
-- Bool.lt_of_le_of_lt
protected theorem lt_of_le_of_lt : ∀ {x y z : Bool}, x ≤ y → y < z → x < z 
Arguments: {x y z : Bool}
Goal: x ≤ y → y < z → x < z
-- Bool.lt_of_lt_of_le
protected theorem lt_of_lt_of_le : ∀ {x y z : Bool}, x < y → y ≤ z → x < z 
Arguments: {x y z : Bool}
Goal: x < y → y ≤ z → x < z
-- Bool.le_of_lt
protected theorem le_of_lt : ∀ {x y : Bool}, x < y → x ≤ y 
Arguments: {x y : Bool}
Goal: x < y → x ≤ y
-- Bool.le_of_eq
protected theorem le_of_eq : ∀ {x y : Bool}, x = y → x ≤ y 
Arguments: {x y : Bool}
Goal: x = y → x ≤ y
-- Bool.ne_of_lt
protected theorem ne_of_lt : ∀ {x y : Bool}, x < y → x ≠ y 
Arguments: {x y : Bool}
Goal: x < y → x ≠ y
-- Bool.lt_of_le_of_ne
protected theorem lt_of_le_of_ne : ∀ {x y : Bool}, x ≤ y → x ≠ y → x < y 
Arguments: {x y : Bool}
Goal: x ≤ y → x ≠ y → x < y
-- Bool.le_of_lt_or_eq
protected theorem le_of_lt_or_eq : ∀ {x y : Bool}, x < y ∨ x = y → x ≤ y 
Arguments: {x y : Bool}
Goal: x < y ∨ x = y → x ≤ y
-- Bool.eq_true_of_true_le
protected theorem eq_true_of_true_le : ∀ {x : Bool}, true ≤ x → x = true 
Arguments: {x : Bool}
Goal: true ≤ x → x = true
-- Bool.eq_false_of_le_false
protected theorem eq_false_of_le_false : ∀ {x : Bool}, x ≤ false → x = false 
Arguments: {x : Bool}
Goal: x ≤ false → x = false
-- Bool.max_eq_or
@[simp] protected theorem max_eq_or : max = or 
Goal: max = or
-- Bool.min_eq_and
@[simp] protected theorem min_eq_and : min = and 
Goal: min = and
-- Bool.not_inj
theorem not_inj : ∀ {x y : Bool}, (!x) = (!y) → x = y 
Arguments: {x y : Bool}
Goal: (!x) = !y → x = y
-- Bool.not_inj_iff
theorem not_inj_iff : ∀ {x y : Bool}, (!x) = (!y) ↔ x = y 
Arguments: {x y : Bool}
Goal: (!x) = !y ↔ x = y
-- Bool.and_or_inj_right
theorem and_or_inj_right : ∀ {m x y : Bool}, (x && m) = (y && m) → (x || m) = (y || m) → x = y 
Arguments: {m x y : Bool}
Goal: (x && m) = (y && m) → (x || m) = (y || m) → x = y
-- Bool.and_or_inj_right_iff
theorem and_or_inj_right_iff :
    ∀ {m x y : Bool}, (x && m) = (y && m) ∧ (x || m) = (y || m) ↔ x = y 
Arguments: {m x y : Bool}
Goal: (x && m) = (y && m) ∧ (x || m) = (y || m) ↔ x = y
-- Bool.and_or_inj_left
theorem and_or_inj_left : ∀ {m x y : Bool}, (m && x) = (m && y) → (m || x) = (m || y) → x = y 
Arguments: {m x y : Bool}
Goal: (m && x) = (m && y) → (m || x) = (m || y) → x = y
-- Bool.and_or_inj_left_iff
theorem and_or_inj_left_iff :
    ∀ {m x y : Bool}, (m && x) = (m && y) ∧ (m || x) = (m || y) ↔ x = y 
Arguments: {m x y : Bool}
Goal: (m && x) = (m && y) ∧ (m || x) = (m || y) ↔ x = y
-- Bool.toNat_false
@[simp] theorem toNat_false : false.toNat = 0 
Goal: false.toNat = 0
-- Bool.toNat_true
@[simp] theorem toNat_true : true.toNat = 1 
Goal: true.toNat = 1
-- Bool.toNat_le
theorem toNat_le (c : Bool) : c.toNat ≤ 1 
Arguments: (c : Bool)
Goal: c.toNat ≤ 1
-- Bool.toNat_lt
theorem toNat_lt (b : Bool) : b.toNat < 2 
Arguments: (b : Bool)
Goal: b.toNat < 2
-- Bool.toNat_eq_zero
@[simp] theorem toNat_eq_zero (b : Bool) : b.toNat = 0 ↔ b = false 
Arguments: (b : Bool)
Goal: b.toNat = 0 ↔ b = false
-- Bool.toNat_eq_one
@[simp] theorem toNat_eq_one  (b : Bool) : b.toNat = 1 ↔ b = true 
Arguments: (b : Bool)
Goal: b.toNat = 1 ↔ b = true
-- Bool.if_true_left
@[simp] theorem if_true_left  (p : Prop) [h : Decidable p] (f : Bool) :
    (ite p true f) = (p || f) 
Arguments: (p : Prop) [h : Decidable p] (f : Bool)
Goal: (if p then true else f) = (decide p || f)
-- Bool.if_false_left
@[simp] theorem if_false_left  (p : Prop) [h : Decidable p] (f : Bool) :
    (ite p false f) = (!p && f) 
Arguments: (p : Prop) [h : Decidable p] (f : Bool)
Goal: (if p then false else f) = (!decide p && f)
-- Bool.if_true_right
@[simp] theorem if_true_right  (p : Prop) [h : Decidable p] (t : Bool) :
    (ite p t true) = (!(p : Bool) || t) 
Arguments: (p : Prop) [h : Decidable p] (t : Bool)
Goal: (if p then t else true) = (!decide p || t)
-- Bool.if_false_right
@[simp] theorem if_false_right  (p : Prop) [h : Decidable p] (t : Bool) :
    (ite p t false) = (p && t) 
Arguments: (p : Prop) [h : Decidable p] (t : Bool)
Goal: (if p then t else false) = (decide p && t)
-- Bool.ite_eq_true_distrib
@[simp] theorem ite_eq_true_distrib (p : Prop) [h : Decidable p] (t f : Bool) :
    (ite p t f = true) = ite p (t = true) (f = true) 
Arguments: (p : Prop) [h : Decidable p] (t f : Bool)
Goal: ((if p then t else f) = true) = if p then t = true else f = true
-- Bool.ite_eq_false_distrib
@[simp] theorem ite_eq_false_distrib (p : Prop) [h : Decidable p] (t f : Bool) :
    (ite p t f = false) = ite p (t = false) (f = false) 
Arguments: (p : Prop) [h : Decidable p] (t f : Bool)
Goal: ((if p then t else f) = false) = if p then t = false else f = false
-- Bool.not_ite_eq_true_eq_true
@[simp]
theorem not_ite_eq_true_eq_true (p : Prop) [h : Decidable p] (b c : Bool) :
  ¬(ite p (b = true) (c = true)) ↔ (ite p (b = false) (c = false)) 
Arguments: (p : Prop) [h : Decidable p] (b c : Bool)
Goal: (¬if p then b = true else c = true) ↔ if p then b = false else c = false
-- Bool.not_ite_eq_false_eq_false
@[simp]
theorem not_ite_eq_false_eq_false (p : Prop) [h : Decidable p] (b c : Bool) :
  ¬(ite p (b = false) (c = false)) ↔ (ite p (b = true) (c = true)) 
Arguments: (p : Prop) [h : Decidable p] (b c : Bool)
Goal: (¬if p then b = false else c = false) ↔ if p then b = true else c = true
-- Bool.not_ite_eq_true_eq_false
@[simp]
theorem not_ite_eq_true_eq_false (p : Prop) [h : Decidable p] (b c : Bool) :
  ¬(ite p (b = true) (c = false)) ↔ (ite p (b = false) (c = true)) 
Arguments: (p : Prop) [h : Decidable p] (b c : Bool)
Goal: (¬if p then b = true else c = false) ↔ if p then b = false else c = true
-- Bool.not_ite_eq_false_eq_true
@[simp]
theorem not_ite_eq_false_eq_true (p : Prop) [h : Decidable p] (b c : Bool) :
  ¬(ite p (b = false) (c = true)) ↔ (ite p (b = true) (c = false)) 
Arguments: (p : Prop) [h : Decidable p] (b c : Bool)
Goal: (¬if p then b = false else c = true) ↔ if p then b = true else c = false
-- Bool.eq_false_imp_eq_true
@[simp] theorem eq_false_imp_eq_true : ∀(b:Bool), (b = false → b = true) ↔ (b = true) 
Arguments: (b : Bool)
Goal: b = false → b = true ↔ b = true
-- Bool.eq_true_imp_eq_false
@[simp] theorem eq_true_imp_eq_false : ∀(b:Bool), (b = true → b = false) ↔ (b = false) 
Arguments: (b : Bool)
Goal: b = true → b = false ↔ b = false
-- Bool.cond_eq_ite
theorem cond_eq_ite {α} (b : Bool) (t e : α) : cond b t e = if b then t else e 
Arguments: {α : Type u_1} (b : Bool) (t e : α)
Goal: (bif b then t else e) = if b = true then t else e
-- Bool.cond_eq_if
theorem cond_eq_if : (bif b then x else y) = (if b then x else y) 
Arguments: {b : Bool}
Goal: ∀ {α : Type u_1} {x y : α}, (bif b then x else y) = if b = true then x else y
-- Bool.cond_not
@[simp] theorem cond_not (b : Bool) (t e : α) : cond (!b) t e = cond b e t 
Arguments: {α : Type u_1} (b : Bool) (t e : α)
Goal: (bif !b then t else e) = bif b then e else t
-- Bool.cond_self
@[simp] theorem cond_self (c : Bool) (t : α) : cond c t t = t 
Arguments: {α : Type u_1} (c : Bool) (t : α)
Goal: (bif c then t else t) = t
-- Bool.cond_decide
theorem cond_decide {α} (p : Prop) [Decidable p] (t e : α) :
    cond (decide p) t e = if p then t else e 
Arguments: {α : Type u_1} (p : Prop) [Decidable p] (t e : α)
Goal: (bif decide p then t else e) = if p then t else e
-- Bool.cond_eq_ite_iff
@[simp] theorem cond_eq_ite_iff (a : Bool) (p : Prop) [h : Decidable p] (x y u v : α) :
  (cond a x y = ite p u v) ↔ ite a x y = ite p u v 
Arguments: {α : Type u_1} (a : Bool) (p : Prop) [h : Decidable p] (x y u v : α)
Goal: ((bif a then x else y) = if p then u else v) ↔ (if a = true then x else y) = if p then u else v
-- Bool.ite_eq_cond_iff
@[simp] theorem ite_eq_cond_iff (p : Prop) [h : Decidable p] (a : Bool) (x y u v : α) :
  (ite p x y = cond a u v) ↔ ite p x y = ite a u v 
Arguments: {α : Type u_1} (p : Prop) [h : Decidable p] (a : Bool) (x y u v : α)
Goal: ((if p then x else y) = bif a then u else v) ↔ (if p then x else y) = if a = true then u else v
-- Bool.cond_eq_true_distrib
@[simp] theorem cond_eq_true_distrib : ∀(c t f : Bool),
    (cond c t f = true) = ite (c = true) (t = true) (f = true) 
Arguments: (c t f : Bool)
Goal: ((bif c then t else f) = true) = if c = true then t = true else f = true
-- Bool.cond_eq_false_distrib
@[simp] theorem cond_eq_false_distrib : ∀(c t f : Bool),
    (cond c t f = false) = ite (c = true) (t = false) (f = false) 
Arguments: (c t f : Bool)
Goal: ((bif c then t else f) = false) = if c = true then t = false else f = false
-- Bool.cond_true
protected theorem cond_true  {α : Type u} {a b : α} : cond true  a b = a 
Arguments: {α : Type u} {a b : α}
Goal: (bif true then a else b) = a
-- Bool.cond_false
protected theorem cond_false {α : Type u} {a b : α} : cond false a b = b 
Arguments: {α : Type u} {a b : α}
Goal: (bif false then a else b) = b
-- Bool.cond_true_left
@[simp] theorem cond_true_left   : ∀(c f : Bool), cond c true f  = ( c || f) 
Arguments: (c f : Bool)
Goal: (bif c then true else f) = (c || f)
-- Bool.cond_false_left
@[simp] theorem cond_false_left  : ∀(c f : Bool), cond c false f = (!c && f) 
Arguments: (c f : Bool)
Goal: (bif c then false else f) = (!c && f)
-- Bool.cond_true_right
@[simp] theorem cond_true_right  : ∀(c t : Bool), cond c t true  = (!c || t) 
Arguments: (c t : Bool)
Goal: (bif c then t else true) = (!c || t)
-- Bool.cond_false_right
@[simp] theorem cond_false_right : ∀(c t : Bool), cond c t false = ( c && t) 
Arguments: (c t : Bool)
Goal: (bif c then t else false) = (c && t)
-- Bool.cond_true_same
@[simp] theorem cond_true_same  : ∀(c b : Bool), cond c c b = (c || b) 
Arguments: (c b : Bool)
Goal: (bif c then c else b) = (c || b)
-- Bool.cond_false_same
@[simp] theorem cond_false_same : ∀(c b : Bool), cond c b c = (c && b) 
Arguments: (c b : Bool)
Goal: (bif c then b else c) = (c && b)
-- Bool.decide_coe
protected theorem decide_coe (b : Bool) [Decidable (b = true)] : decide (b = true) = b 
Arguments: (b : Bool) [Decidable (b = true)]
Goal: decide (b = true) = b
-- Bool.decide_and
@[simp] theorem decide_and (p q : Prop) [dpq : Decidable (p ∧ q)] [dp : Decidable p] [dq : Decidable q] :
    decide (p ∧ q) = (p && q) 
Arguments: (p q : Prop) [dpq : Decidable (p ∧ q)] [dp : Decidable p] [dq : Decidable q]
Goal: decide (p ∧ q) = (decide p && decide q)
-- Bool.decide_or
@[simp] theorem decide_or (p q : Prop) [dpq : Decidable (p ∨ q)] [dp : Decidable p] [dq : Decidable q] :
    decide (p ∨ q) = (p || q) 
Arguments: (p q : Prop) [dpq : Decidable (p ∨ q)] [dp : Decidable p] [dq : Decidable q]
Goal: decide (p ∨ q) = (decide p || decide q)
-- Bool.decide_iff_dist
@[simp] theorem decide_iff_dist (p q : Prop) [dpq : Decidable (p ↔ q)] [dp : Decidable p] [dq : Decidable q] :
    decide (p ↔ q) = (decide p == decide q) 
Arguments: (p q : Prop) [dpq : Decidable (p ↔ q)] [dp : Decidable p] [dq : Decidable q]
Goal: decide (p ↔ q) = (decide p == decide q)
-- false_eq_decide_iff
@[simp] theorem false_eq_decide_iff {p : Prop} [h : Decidable p] : false = decide p ↔ ¬p 
Arguments: {p : Prop} [h : Decidable p]
Goal: false = decide p ↔ ¬p
-- true_eq_decide_iff
@[simp] theorem true_eq_decide_iff {p : Prop} [h : Decidable p] : true = decide p ↔ p 
Arguments: {p : Prop} [h : Decidable p]
Goal: true = decide p ↔ p
-- List.length_add_eq_lengthTRAux
theorem length_add_eq_lengthTRAux (as : List α) (n : Nat) : as.length + n = as.lengthTRAux n 
Arguments: {α : Type u_1} (as : List α) (n : Nat)
Goal: as.length + n = as.lengthTRAux n
-- List.length_eq_lengthTR
@[csimp] theorem length_eq_lengthTR : @List.length = @List.lengthTR 
Goal: @List.length = @List.lengthTR
-- List.set_eq_setTR.go
@[csimp] theorem set_eq_setTR : @set = @setTR 
Arguments: (α : Type u_1) (l : List α) (a : α) (acc : Array α) (xs : List α) (n : Nat)
Goal: l = acc.data ++ xs → List.setTR.go l a xs n acc = acc.data ++ xs.set n a
-- List.set_eq_setTR
@[csimp] theorem set_eq_setTR : @set = @setTR 
Goal: @List.set = @List.setTR
-- List.mapTR_loop_eq
theorem mapTR_loop_eq (f : α → β) (as : List α) (bs : List β) :
    mapTR.loop f as bs = bs.reverse ++ map f as 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (as : List α) (bs : List β)
Goal: List.mapTR.loop f as bs = bs.reverse ++ List.map f as
-- List.map_eq_mapTR
@[csimp] theorem map_eq_mapTR : @map = @mapTR 
Goal: @List.map = @List.mapTR
-- List.filterTR_loop_eq
theorem filterTR_loop_eq (p : α → Bool) (as bs : List α) :
    filterTR.loop p as bs = bs.reverse ++ filter p as 
Arguments: {α : Type u_1} (p : α → Bool) (as bs : List α)
Goal: List.filterTR.loop p as bs = bs.reverse ++ List.filter p as
-- List.filter_eq_filterTR
@[csimp] theorem filter_eq_filterTR : @filter = @filterTR 
Goal: @List.filter = @List.filterTR
-- List.filterMap_eq_filterMapTR
@[csimp] theorem filterMap_eq_filterMapTR : @List.filterMap = @filterMapTR 
Goal: @List.filterMap = @List.filterMapTR
-- List.filterMap_eq_filterMapTR.go
@[csimp] theorem filterMap_eq_filterMapTR : @List.filterMap = @filterMapTR 
Arguments: (α : Type u_2) (β : Type u_1) (f : α → Option β) (as : List α) (acc : Array β)
Goal: List.filterMapTR.go f as acc = acc.data ++ List.filterMap f as
-- List.foldr_eq_foldrTR
@[csimp] theorem foldr_eq_foldrTR : @foldr = @foldrTR 
Goal: @List.foldr = @List.foldrTR
-- List.bind_eq_bindTR
@[csimp] theorem bind_eq_bindTR : @List.bind = @bindTR 
Goal: @List.bind = @List.bindTR
-- List.bind_eq_bindTR.go
@[csimp] theorem bind_eq_bindTR : @List.bind = @bindTR 
Arguments: (α : Type u_2) (β : Type u_1) (f : α → List β) (as : List α) (acc : Array β)
Goal: List.bindTR.go f as acc = acc.data ++ as.bind f