l3lab/ntp-mathlib huggingface dataset:
@[simp]
theorem decide_and (p q : Prop) [Decidable p] [Decidable q] : decide (p ∧ q) = (p && q) := by
  by_cases p <;> by_cases q <;> 

Proof state:
case neg
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h✝¹ : p
h✝ : ¬q
⊢ decide (p ∧ q) = (decide p && decide q)

Next tactic:
simp [*]
@[simp]
theorem decide_and (p q : Prop) [Decidable p] [Decidable q] : decide (p ∧ q) = (p && q) := by
  by_cases p <;> by_cases q <;> 

Proof state:
case pos
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h✝¹ : ¬p
h✝ : q
⊢ decide (p ∧ q) = (decide p && decide q)

Next tactic:
simp [*]
@[simp]
theorem decide_and (p q : Prop) [Decidable p] [Decidable q] : decide (p ∧ q) = (p && q) := by
  by_cases p <;> by_cases q <;> 

Proof state:
case neg
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h✝¹ : ¬p
h✝ : ¬q
⊢ decide (p ∧ q) = (decide p && decide q)

Next tactic:
simp [*]
@[simp]
theorem decide_or (p q : Prop) [Decidable p] [Decidable q] : decide (p ∨ q) = (p || q) := by
  

Proof state:
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
⊢ decide (p ∨ q) = (decide p || decide q)

Next tactic:
by_cases p
@[simp]
theorem decide_or (p q : Prop) [Decidable p] [Decidable q] : decide (p ∨ q) = (p || q) := by
  by_cases p <;> 

Proof state:
case pos
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h✝ : p
⊢ decide (p ∨ q) = (decide p || decide q)

Next tactic:
by_cases q
@[simp]
theorem decide_or (p q : Prop) [Decidable p] [Decidable q] : decide (p ∨ q) = (p || q) := by
  by_cases p <;> 

Proof state:
case neg
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h✝ : ¬p
⊢ decide (p ∨ q) = (decide p || decide q)

Next tactic:
by_cases q
@[simp]
theorem decide_or (p q : Prop) [Decidable p] [Decidable q] : decide (p ∨ q) = (p || q) := by
  by_cases p <;> by_cases q <;> 

Proof state:
case pos
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h✝¹ : p
h✝ : q
⊢ decide (p ∨ q) = (decide p || decide q)

Next tactic:
simp [*]
@[simp]
theorem decide_or (p q : Prop) [Decidable p] [Decidable q] : decide (p ∨ q) = (p || q) := by
  by_cases p <;> by_cases q <;> 

Proof state:
case neg
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h✝¹ : p
h✝ : ¬q
⊢ decide (p ∨ q) = (decide p || decide q)

Next tactic:
simp [*]
@[simp]
theorem decide_or (p q : Prop) [Decidable p] [Decidable q] : decide (p ∨ q) = (p || q) := by
  by_cases p <;> by_cases q <;> 

Proof state:
case pos
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h✝¹ : ¬p
h✝ : q
⊢ decide (p ∨ q) = (decide p || decide q)

Next tactic:
simp [*]
@[simp]
theorem decide_or (p q : Prop) [Decidable p] [Decidable q] : decide (p ∨ q) = (p || q) := by
  by_cases p <;> by_cases q <;> 

Proof state:
case neg
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h✝¹ : ¬p
h✝ : ¬q
⊢ decide (p ∨ q) = (decide p || decide q)

Next tactic:
simp [*]
theorem eq_iff_eq_true_iff {a b : Bool} : a = b ↔ ((a = true) ↔ (b = true)) := by
  

Proof state:
a b : Bool
⊢ a = b ↔ (a = true ↔ b = true)

Next tactic:
cases a
theorem eq_iff_eq_true_iff {a b : Bool} : a = b ↔ ((a = true) ↔ (b = true)) := by
  cases a <;> 

Proof state:
case false
b : Bool
⊢ false = b ↔ (false = true ↔ b = true)

Next tactic:
cases b
theorem eq_iff_eq_true_iff {a b : Bool} : a = b ↔ ((a = true) ↔ (b = true)) := by
  cases a <;> 

Proof state:
case true
b : Bool
⊢ true = b ↔ (true = true ↔ b = true)

Next tactic:
cases b
theorem eq_iff_eq_true_iff {a b : Bool} : a = b ↔ ((a = true) ↔ (b = true)) := by
  cases a <;> cases b <;> 

Proof state:
case false.false
⊢ false = false ↔ (false = true ↔ false = true)

Next tactic:
simp
theorem eq_iff_eq_true_iff {a b : Bool} : a = b ↔ ((a = true) ↔ (b = true)) := by
  cases a <;> cases b <;> 

Proof state:
case false.true
⊢ false = true ↔ (false = true ↔ true = true)

Next tactic:
simp
theorem eq_iff_eq_true_iff {a b : Bool} : a = b ↔ ((a = true) ↔ (b = true)) := by
  cases a <;> cases b <;> 

Proof state:
case true.false
⊢ true = false ↔ (true = true ↔ false = true)

Next tactic:
simp
theorem eq_iff_eq_true_iff {a b : Bool} : a = b ↔ ((a = true) ↔ (b = true)) := by
  cases a <;> cases b <;> 

Proof state:
case true.true
⊢ true = true ↔ (true = true ↔ true = true)

Next tactic:
simp
theorem beq_eq_decide_eq {α} [BEq α] [LawfulBEq α] [DecidableEq α]
    (a b : α) : (a == b) = decide (a = b) := by
  

Proof state:
α : Type u_1
inst✝² : BEq α
inst✝¹ : LawfulBEq α
inst✝ : DecidableEq α
a b : α
⊢ (a == b) = decide (a = b)

Next tactic:
cases h : a == b
theorem beq_eq_decide_eq {α} [BEq α] [LawfulBEq α] [DecidableEq α]
    (a b : α) : (a == b) = decide (a = b) := by
  cases h : a == b
  · 

Proof state:
case false
α : Type u_1
inst✝² : BEq α
inst✝¹ : LawfulBEq α
inst✝ : DecidableEq α
a b : α
h : (a == b) = false
⊢ false = decide (a = b)

Next tactic:
simp [ne_of_beq_false h]
theorem beq_eq_decide_eq {α} [BEq α] [LawfulBEq α] [DecidableEq α]
    (a b : α) : (a == b) = decide (a = b) := by
  cases h : a == b
  · simp [ne_of_beq_false h]
  · 

Proof state:
case true
α : Type u_1
inst✝² : BEq α
inst✝¹ : LawfulBEq α
inst✝ : DecidableEq α
a b : α
h : (a == b) = true
⊢ true = decide (a = b)

Next tactic:
simp [eq_of_beq h]
theorem beq_comm {α} [BEq α] [LawfulBEq α] {a b : α} : (a == b) = (b == a) :=
  eq_iff_eq_true_iff.2 (by 

Proof state:
α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a b : α
⊢ (a == b) = true ↔ (b == a) = true

Next tactic:
simp [@eq_comm α]
theorem dichotomy (b : Bool) : b = false ∨ b = true := by 

Proof state:
b : Bool
⊢ b = false ∨ b = true

Next tactic:
cases b
theorem dichotomy (b : Bool) : b = false ∨ b = true := by cases b <;> 

Proof state:
case false
⊢ false = false ∨ false = true

Next tactic:
simp
theorem dichotomy (b : Bool) : b = false ∨ b = true := by cases b <;> 

Proof state:
case true
⊢ true = false ∨ true = true

Next tactic:
simp
@[simp]
theorem forall_bool {p : Bool → Prop} : (∀ b, p b) ↔ p false ∧ p true :=
  ⟨fun h ↦ by 

Proof state:
p : Bool → Prop
h : ∀ (b : Bool), p b
⊢ p false ∧ p true

Next tactic:
simp [h]
@[simp]
theorem forall_bool {p : Bool → Prop} : (∀ b, p b) ↔ p false ∧ p true :=
  ⟨fun h ↦ by simp [h], fun ⟨h₁, h₂⟩ b ↦ by 

Proof state:
p : Bool → Prop
x✝ : p false ∧ p true
b : Bool
h₁ : p false
h₂ : p true
⊢ p b

Next tactic:
cases b
@[simp]
theorem forall_bool {p : Bool → Prop} : (∀ b, p b) ↔ p false ∧ p true :=
  ⟨fun h ↦ by simp [h], fun ⟨h₁, h₂⟩ b ↦ by cases b <;> 

Proof state:
case false
p : Bool → Prop
x✝ : p false ∧ p true
h₁ : p false
h₂ : p true
⊢ p false

Next tactic:
assumption
@[simp]
theorem forall_bool {p : Bool → Prop} : (∀ b, p b) ↔ p false ∧ p true :=
  ⟨fun h ↦ by simp [h], fun ⟨h₁, h₂⟩ b ↦ by cases b <;> 

Proof state:
case true
p : Bool → Prop
x✝ : p false ∧ p true
h₁ : p false
h₂ : p true
⊢ p true

Next tactic:
assumption
@[simp]
theorem exists_bool {p : Bool → Prop} : (∃ b, p b) ↔ p false ∨ p true :=
  ⟨fun ⟨b, h⟩ ↦ by 

Proof state:
p : Bool → Prop
x✝ : ∃ b, p b
b : Bool
h : p b
⊢ p false ∨ p true

Next tactic:
cases b
@[simp]
theorem exists_bool {p : Bool → Prop} : (∃ b, p b) ↔ p false ∨ p true :=
  ⟨fun ⟨b, h⟩ ↦ by cases b; 

Proof state:
case false
p : Bool → Prop
x✝ : ∃ b, p b
h : p false
⊢ p false ∨ p true
case true p : Bool → Prop x✝ : ∃ b, p b h : p true ⊢ p false ∨ p true

Next tactic:
exact Or.inl h
@[simp]
theorem exists_bool {p : Bool → Prop} : (∃ b, p b) ↔ p false ∨ p true :=
  ⟨fun ⟨b, h⟩ ↦ by cases b; exact Or.inl h; 

Proof state:
case true
p : Bool → Prop
x✝ : ∃ b, p b
h : p true
⊢ p false ∨ p true

Next tactic:
exact Or.inr h
theorem cond_eq_ite {α} (b : Bool) (t e : α) : cond b t e = if b then t else e := by
  

Proof state:
α : Type u_1
b : Bool
t e : α
⊢ (bif b then t else e) = if b = true then t else e

Next tactic:
cases b
theorem cond_eq_ite {α} (b : Bool) (t e : α) : cond b t e = if b then t else e := by
  cases b <;> 

Proof state:
case false
α : Type u_1
t e : α
⊢ (bif false then t else e) = if false = true then t else e

Next tactic:
simp
theorem cond_eq_ite {α} (b : Bool) (t e : α) : cond b t e = if b then t else e := by
  cases b <;> 

Proof state:
case true
α : Type u_1
t e : α
⊢ (bif true then t else e) = if true = true then t else e

Next tactic:
simp
@[simp]
theorem cond_decide {α} (p : Prop) [Decidable p] (t e : α) :
    cond (decide p) t e = if p then t else e := by
  

Proof state:
α : Type u_1
p : Prop
inst✝ : Decidable p
t e : α
⊢ (bif decide p then t else e) = if p then t else e

Next tactic:
by_cases p
@[simp]
theorem cond_decide {α} (p : Prop) [Decidable p] (t e : α) :
    cond (decide p) t e = if p then t else e := by
  by_cases p <;> 

Proof state:
case pos
α : Type u_1
p : Prop
inst✝ : Decidable p
t e : α
h✝ : p
⊢ (bif decide p then t else e) = if p then t else e

Next tactic:
simp [*]
@[simp]
theorem cond_decide {α} (p : Prop) [Decidable p] (t e : α) :
    cond (decide p) t e = if p then t else e := by
  by_cases p <;> 

Proof state:
case neg
α : Type u_1
p : Prop
inst✝ : Decidable p
t e : α
h✝ : ¬p
⊢ (bif decide p then t else e) = if p then t else e

Next tactic:
simp [*]
@[simp]
theorem cond_not {α} (b : Bool) (t e : α) : cond (!b) t e = cond b e t := by 

Proof state:
α : Type u_1
b : Bool
t e : α
⊢ (bif !b then t else e) = bif b then e else t

Next tactic:
cases b
@[simp]
theorem cond_not {α} (b : Bool) (t e : α) : cond (!b) t e = cond b e t := by cases b <;> 

Proof state:
case false
α : Type u_1
t e : α
⊢ (bif !false then t else e) = bif false then e else t

Next tactic:
rfl
@[simp]
theorem cond_not {α} (b : Bool) (t e : α) : cond (!b) t e = cond b e t := by cases b <;> 

Proof state:
case true
α : Type u_1
t e : α
⊢ (bif !true then t else e) = bif true then e else t

Next tactic:
rfl
theorem coe_iff_coe : ∀ {a b : Bool}, (a ↔ b) ↔ a = b := by 

Proof state:
⊢ ∀ {a b : Bool}, (a = true ↔ b = true) ↔ a = b

Next tactic:
decide
theorem eq_true_of_ne_false : ∀ {a : Bool}, a ≠ false → a = true := by 

Proof state:
⊢ ∀ {a : Bool}, a ≠ false → a = true

Next tactic:
decide
theorem eq_false_of_ne_true : ∀ {a : Bool}, a ≠ true → a = false := by 

Proof state:
⊢ ∀ {a : Bool}, a ≠ true → a = false

Next tactic:
decide
theorem or_inl {a b : Bool} (H : a) : a || b := by 

Proof state:
a b : Bool
H : a = true
⊢ (a || b) = true

Next tactic:
simp [H]
theorem or_inr {a b : Bool} (H : b) : a || b := by 

Proof state:
a b : Bool
H : b = true
⊢ (a || b) = true

Next tactic:
cases a
theorem or_inr {a b : Bool} (H : b) : a || b := by cases a <;> 

Proof state:
case false
b : Bool
H : b = true
⊢ (false || b) = true

Next tactic:
simp [H]
theorem or_inr {a b : Bool} (H : b) : a || b := by cases a <;> 

Proof state:
case true
b : Bool
H : b = true
⊢ (true || b) = true

Next tactic:
simp [H]
theorem and_elim_left : ∀ {a b : Bool}, a && b → a := by 

Proof state:
⊢ ∀ {a b : Bool}, (a && b) = true → a = true

Next tactic:
decide
theorem and_intro : ∀ {a b : Bool}, a → b → a && b := by 

Proof state:
⊢ ∀ {a b : Bool}, a = true → b = true → (a && b) = true

Next tactic:
decide
theorem and_elim_right : ∀ {a b : Bool}, a && b → b := by 

Proof state:
⊢ ∀ {a b : Bool}, (a && b) = true → b = true

Next tactic:
decide
lemma eq_not_iff : ∀ {a b : Bool}, a = !b ↔ a ≠ b := by 

Proof state:
⊢ ∀ {a b : Bool}, a = !b ↔ a ≠ b

Next tactic:
decide
lemma not_eq_iff : ∀ {a b : Bool}, !a = b ↔ a ≠ b := by 

Proof state:
⊢ ∀ {a b : Bool}, (!decide (a = b)) = true ↔ a ≠ b

Next tactic:
decide
@[simp]
theorem not_eq_not : ∀ {a b : Bool}, ¬a = !b ↔ a = b := by 

Proof state:
⊢ ∀ {a b : Bool}, ¬a = !b ↔ a = b

Next tactic:
decide
@[simp]
theorem not_not_eq : ∀ {a b : Bool}, ¬(!a) = b ↔ a = b := by 

Proof state:
⊢ ∀ {a b : Bool}, ¬(!a) = b ↔ a = b

Next tactic:
decide
lemma not_ne_self : ∀ b : Bool, (!b) ≠ b := by 

Proof state:
⊢ ∀ (b : Bool), (!b) ≠ b

Next tactic:
decide
lemma self_ne_not : ∀ b : Bool, b ≠ !b := by 

Proof state:
⊢ ∀ (b : Bool), b ≠ !b

Next tactic:
decide
lemma eq_or_eq_not : ∀ a b, a = b ∨ a = !b := by 

Proof state:
⊢ ∀ (a b : Bool), a = b ∨ a = !b

Next tactic:
decide
theorem not_iff_not : ∀ {b : Bool}, !b ↔ ¬b := by 

Proof state:
⊢ ∀ {b : Bool}, (!b) = true ↔ ¬b = true

Next tactic:
simp
theorem eq_true_of_not_eq_false' {a : Bool} : !a = false → a = true := by
  

Proof state:
a : Bool
⊢ (!decide (a = false)) = true → a = true

Next tactic:
cases a
theorem eq_true_of_not_eq_false' {a : Bool} : !a = false → a = true := by
  cases a <;> 

Proof state:
case false
⊢ (!decide (false = false)) = true → false = true

Next tactic:
decide
theorem eq_true_of_not_eq_false' {a : Bool} : !a = false → a = true := by
  cases a <;> 

Proof state:
case true
⊢ (!decide (true = false)) = true → true = true

Next tactic:
decide
theorem eq_false_of_not_eq_true' {a : Bool} : !a = true → a = false := by
  

Proof state:
a : Bool
⊢ (!decide (a = true)) = true → a = false

Next tactic:
cases a
theorem eq_false_of_not_eq_true' {a : Bool} : !a = true → a = false := by
  cases a <;> 

Proof state:
case false
⊢ (!decide (false = true)) = true → false = false

Next tactic:
decide
theorem eq_false_of_not_eq_true' {a : Bool} : !a = true → a = false := by
  cases a <;> 

Proof state:
case true
⊢ (!decide (true = true)) = true → true = false

Next tactic:
decide
theorem bne_eq_xor : bne = xor := by 

Proof state:
⊢ bne = xor

Next tactic:
funext a b
theorem bne_eq_xor : bne = xor := by funext a b; 

Proof state:
case h.h
a b : Bool
⊢ (a != b) = xor a b

Next tactic:
revert a b
theorem bne_eq_xor : bne = xor := by funext a b; revert a b; 

Proof state:
case h.h
⊢ ∀ (a b : Bool), (a != b) = xor a b

Next tactic:
decide
theorem xor_iff_ne : ∀ {x y : Bool}, xor x y = true ↔ x ≠ y := by 

Proof state:
⊢ ∀ {x y : Bool}, xor x y = true ↔ x ≠ y

Next tactic:
decide
instance linearOrder : LinearOrder Bool where
  le_refl := by 

Proof state:
⊢ ∀ (a : Bool), a ≤ a

Next tactic:
decide
instance linearOrder : LinearOrder Bool where
  le_refl := by decide
  le_trans := by 

Proof state:
⊢ ∀ (a b c : Bool), a ≤ b → b ≤ c → a ≤ c

Next tactic:
decide
instance linearOrder : LinearOrder Bool where
  le_refl := by decide
  le_trans := by decide
  le_antisymm := by decide
  le_total := by decide
  decidableLE := inferInstance
  lt_iff_le_not_le := by 

Proof state:
⊢ ∀ (a b : Bool), a < b ↔ a ≤ b ∧ ¬b ≤ a

Next tactic:
decide
instance linearOrder : LinearOrder Bool where
  le_refl := by decide
  le_trans := by decide
  le_antisymm := by 

Proof state:
⊢ ∀ (a b : Bool), a ≤ b → b ≤ a → a = b

Next tactic:
decide
instance linearOrder : LinearOrder Bool where
  le_refl := by decide
  le_trans := by decide
  le_antisymm := by decide
  le_total := by 

Proof state:
⊢ ∀ (a b : Bool), a ≤ b ∨ b ≤ a

Next tactic:
decide
instance linearOrder : LinearOrder Bool where
  le_refl := by decide
  le_trans := by decide
  le_antisymm := by decide
  le_total := by decide
  decidableLE := inferInstance
  lt_iff_le_not_le := by decide
  max_def := by decide
  min_def := by 

Proof state:
⊢ ∀ (a b : Bool), min a b = if a ≤ b then a else b

Next tactic:
decide
instance linearOrder : LinearOrder Bool where
  le_refl := by decide
  le_trans := by decide
  le_antisymm := by decide
  le_total := by decide
  decidableLE := inferInstance
  lt_iff_le_not_le := by decide
  max_def := by 

Proof state:
⊢ ∀ (a b : Bool), max a b = if a ≤ b then b else a

Next tactic:
decide
theorem lt_iff : ∀ {x y : Bool}, x < y ↔ x = false ∧ y = true := by 

Proof state:
⊢ ∀ {x y : Bool}, x < y ↔ x = false ∧ y = true

Next tactic:
decide
theorem le_iff_imp : ∀ {x y : Bool}, x ≤ y ↔ x → y := by 

Proof state:
⊢ ∀ {x y : Bool}, x ≤ y ↔ x = true → y = true

Next tactic:
decide
theorem and_le_left : ∀ x y : Bool, (x && y) ≤ x := by 

Proof state:
⊢ ∀ (x y : Bool), (x && y) ≤ x

Next tactic:
decide
theorem and_le_right : ∀ x y : Bool, (x && y) ≤ y := by 

Proof state:
⊢ ∀ (x y : Bool), (x && y) ≤ y

Next tactic:
decide
theorem le_and : ∀ {x y z : Bool}, x ≤ y → x ≤ z → x ≤ (y && z) := by 

Proof state:
⊢ ∀ {x y z : Bool}, x ≤ y → x ≤ z → x ≤ (y && z)

Next tactic:
decide
theorem left_le_or : ∀ x y : Bool, x ≤ (x || y) := by 

Proof state:
⊢ ∀ (x y : Bool), x ≤ (x || y)

Next tactic:
decide
theorem right_le_or : ∀ x y : Bool, y ≤ (x || y) := by 

Proof state:
⊢ ∀ (x y : Bool), y ≤ (x || y)

Next tactic:
decide
theorem or_le : ∀ {x y z}, x ≤ z → y ≤ z → (x || y) ≤ z := by 

Proof state:
⊢ ∀ {x y z : Bool}, x ≤ z → y ≤ z → (x || y) ≤ z

Next tactic:
decide
@[simp] lemma toNat_beq_zero (b : Bool) : (b.toNat == 0) = !b := by 

Proof state:
b : Bool
⊢ (toNat b == 0) = !b

Next tactic:
cases b
@[simp] lemma toNat_beq_zero (b : Bool) : (b.toNat == 0) = !b := by cases b <;> 

Proof state:
case false
⊢ (toNat false == 0) = !false

Next tactic:
rfl
@[simp] lemma toNat_beq_zero (b : Bool) : (b.toNat == 0) = !b := by cases b <;> 

Proof state:
case true
⊢ (toNat true == 0) = !true

Next tactic:
rfl
@[simp] lemma toNat_bne_zero (b : Bool) : (b.toNat != 0) =  b := by 

Proof state:
b : Bool
⊢ (toNat b != 0) = b

Next tactic:
simp [bne]
@[simp] lemma toNat_beq_one  (b : Bool) : (b.toNat == 1) =  b := by 

Proof state:
b : Bool
⊢ (toNat b == 1) = b

Next tactic:
cases b
@[simp] lemma toNat_beq_one  (b : Bool) : (b.toNat == 1) =  b := by cases b <;> 

Proof state:
case false
⊢ (toNat false == 1) = false

Next tactic:
rfl
@[simp] lemma toNat_beq_one  (b : Bool) : (b.toNat == 1) =  b := by cases b <;> 

Proof state:
case true
⊢ (toNat true == 1) = true

Next tactic:
rfl
@[simp] lemma toNat_bne_one  (b : Bool) : (b.toNat != 1) = !b := by 

Proof state:
b : Bool
⊢ (toNat b != 1) = !b

Next tactic:
simp [bne]
theorem ofNat_le_ofNat {n m : Nat} (h : n ≤ m) : ofNat n ≤ ofNat m := by
  

Proof state:
n m : ℕ
h : n ≤ m
⊢ ofNat n ≤ ofNat m

Next tactic:
simp only [ofNat, ne_eq, _root_.decide_not]
theorem ofNat_le_ofNat {n m : Nat} (h : n ≤ m) : ofNat n ≤ ofNat m := by
  simp only [ofNat, ne_eq, _root_.decide_not]
  

Proof state:
n m : ℕ
h : n ≤ m
⊢ (!decide (n = 0)) ≤ !decide (m = 0)

Next tactic:
cases Nat.decEq n 0 with
  | isTrue hn => rw [decide_eq_true hn]; exact Bool.false_le _
  | isFalse hn =>
    cases Nat.decEq m 0 with
    | isFalse hm => rw [decide_eq_false hm]; exact Bool.le_true _
    | isTrue hm => subst hm; have h := le_antisymm h (Nat.zero_le n); contradiction
theorem ofNat_le_ofNat {n m : Nat} (h : n ≤ m) : ofNat n ≤ ofNat m := by
  simp only [ofNat, ne_eq, _root_.decide_not]
  

Proof state:
n m : ℕ
h : n ≤ m
x✝ : Decidable (n = 0)
⊢ (!decide (n = 0)) ≤ !decide (m = 0)

Next tactic:
cases Nat.decEq n 0 with
  | isTrue hn => rw [decide_eq_true hn]; exact Bool.false_le _
  | isFalse hn =>
    cases Nat.decEq m 0 with
    | isFalse hm => rw [decide_eq_false hm]; exact Bool.le_true _
    | isTrue hm => subst hm; have h := le_antisymm h (Nat.zero_le n); contradiction
theorem ofNat_le_ofNat {n m : Nat} (h : n ≤ m) : ofNat n ≤ ofNat m := by
  simp only [ofNat, ne_eq, _root_.decide_not]
  cases Nat.decEq n 0 with
  

Proof state:
case isTrue
n m : ℕ
h : n ≤ m
hn : n = 0
⊢ (!decide (n = 0)) ≤ !decide (m = 0)

Next tactic:
| isTrue hn => rw [decide_eq_true hn]; exact Bool.false_le _
theorem ofNat_le_ofNat {n m : Nat} (h : n ≤ m) : ofNat n ≤ ofNat m := by
  simp only [ofNat, ne_eq, _root_.decide_not]
  cases Nat.decEq n 0 with
  | isTrue hn => 

Proof state:
case isTrue
n m : ℕ
h : n ≤ m
hn : n = 0
⊢ (!decide (n = 0)) ≤ !decide (m = 0)

Next tactic:
rw [decide_eq_true hn]
theorem ofNat_le_ofNat {n m : Nat} (h : n ≤ m) : ofNat n ≤ ofNat m := by
  simp only [ofNat, ne_eq, _root_.decide_not]
  cases Nat.decEq n 0 with
  | isTrue hn => rw [decide_eq_true hn]; 

Proof state:
case isTrue
n m : ℕ
h : n ≤ m
hn : n = 0
⊢ (!true) ≤ !decide (m = 0)

Next tactic:
exact Bool.false_le _
theorem ofNat_le_ofNat {n m : Nat} (h : n ≤ m) : ofNat n ≤ ofNat m := by
  simp only [ofNat, ne_eq, _root_.decide_not]
  cases Nat.decEq n 0 with
  | isTrue hn => rw [decide_eq_true hn]; exact Bool.false_le _
  

Proof state:
case isFalse
n m : ℕ
h : n ≤ m
hn : ¬n = 0
⊢ (!decide (n = 0)) ≤ !decide (m = 0)

Next tactic:
| isFalse hn =>
    cases Nat.decEq m 0 with
    | isFalse hm => rw [decide_eq_false hm]; exact Bool.le_true _
    | isTrue hm => subst hm; have h := le_antisymm h (Nat.zero_le n); contradiction
theorem ofNat_le_ofNat {n m : Nat} (h : n ≤ m) : ofNat n ≤ ofNat m := by
  simp only [ofNat, ne_eq, _root_.decide_not]
  cases Nat.decEq n 0 with
  | isTrue hn => rw [decide_eq_true hn]; exact Bool.false_le _
  | isFalse hn =>
    

Proof state:
case isFalse
n m : ℕ
h : n ≤ m
hn : ¬n = 0
⊢ (!decide (n = 0)) ≤ !decide (m = 0)

Next tactic:
cases Nat.decEq m 0 with
    | isFalse hm => rw [decide_eq_false hm]; exact Bool.le_true _
    | isTrue hm => subst hm; have h := le_antisymm h (Nat.zero_le n); contradiction
theorem ofNat_le_ofNat {n m : Nat} (h : n ≤ m) : ofNat n ≤ ofNat m := by
  simp only [ofNat, ne_eq, _root_.decide_not]
  cases Nat.decEq n 0 with
  | isTrue hn => rw [decide_eq_true hn]; exact Bool.false_le _
  | isFalse hn =>
    

Proof state:
case isFalse
n m : ℕ
h : n ≤ m
hn : ¬n = 0
x✝ : Decidable (m = 0)
⊢ (!decide (n = 0)) ≤ !decide (m = 0)

Next tactic:
cases Nat.decEq m 0 with
    | isFalse hm => rw [decide_eq_false hm]; exact Bool.le_true _
    | isTrue hm => subst hm; have h := le_antisymm h (Nat.zero_le n); contradiction
theorem ofNat_le_ofNat {n m : Nat} (h : n ≤ m) : ofNat n ≤ ofNat m := by
  simp only [ofNat, ne_eq, _root_.decide_not]
  cases Nat.decEq n 0 with
  | isTrue hn => rw [decide_eq_true hn]; exact Bool.false_le _
  | isFalse hn =>
    cases Nat.decEq m 0 with
    

Proof state:
case isFalse.isFalse
n m : ℕ
h : n ≤ m
hn : ¬n = 0
hm : ¬m = 0
⊢ (!decide (n = 0)) ≤ !decide (m = 0)

Next tactic:
| isFalse hm => rw [decide_eq_false hm]; exact Bool.le_true _
theorem ofNat_le_ofNat {n m : Nat} (h : n ≤ m) : ofNat n ≤ ofNat m := by
  simp only [ofNat, ne_eq, _root_.decide_not]
  cases Nat.decEq n 0 with
  | isTrue hn => rw [decide_eq_true hn]; exact Bool.false_le _
  | isFalse hn =>
    cases Nat.decEq m 0 with
    | isFalse hm => 

Proof state:
case isFalse.isFalse
n m : ℕ
h : n ≤ m
hn : ¬n = 0
hm : ¬m = 0
⊢ (!decide (n = 0)) ≤ !decide (m = 0)

Next tactic:
rw [decide_eq_false hm]
theorem ofNat_le_ofNat {n m : Nat} (h : n ≤ m) : ofNat n ≤ ofNat m := by
  simp only [ofNat, ne_eq, _root_.decide_not]
  cases Nat.decEq n 0 with
  | isTrue hn => rw [decide_eq_true hn]; exact Bool.false_le _
  | isFalse hn =>
    cases Nat.decEq m 0 with
    | isFalse hm => rw [decide_eq_false hm]; 

Proof state:
case isFalse.isFalse
n m : ℕ
h : n ≤ m
hn : ¬n = 0
hm : ¬m = 0
⊢ (!decide (n = 0)) ≤ !false

Next tactic:
exact Bool.le_true _
theorem ofNat_le_ofNat {n m : Nat} (h : n ≤ m) : ofNat n ≤ ofNat m := by
  simp only [ofNat, ne_eq, _root_.decide_not]
  cases Nat.decEq n 0 with
  | isTrue hn => rw [decide_eq_true hn]; exact Bool.false_le _
  | isFalse hn =>
    cases Nat.decEq m 0 with
    | isFalse hm => rw [decide_eq_false hm]; exact Bool.le_true _
    

Proof state:
case isFalse.isTrue
n m : ℕ
h : n ≤ m
hn : ¬n = 0
hm : m = 0
⊢ (!decide (n = 0)) ≤ !decide (m = 0)

Next tactic:
| isTrue hm => subst hm; have h := le_antisymm h (Nat.zero_le n); contradiction
theorem ofNat_le_ofNat {n m : Nat} (h : n ≤ m) : ofNat n ≤ ofNat m := by
  simp only [ofNat, ne_eq, _root_.decide_not]
  cases Nat.decEq n 0 with
  | isTrue hn => rw [decide_eq_true hn]; exact Bool.false_le _
  | isFalse hn =>
    cases Nat.decEq m 0 with
    | isFalse hm => rw [decide_eq_false hm]; exact Bool.le_true _
    | isTrue hm => 

Proof state:
case isFalse.isTrue
n m : ℕ
h : n ≤ m
hn : ¬n = 0
hm : m = 0
⊢ (!decide (n = 0)) ≤ !decide (m = 0)

Next tactic:
subst hm
theorem ofNat_le_ofNat {n m : Nat} (h : n ≤ m) : ofNat n ≤ ofNat m := by
  simp only [ofNat, ne_eq, _root_.decide_not]
  cases Nat.decEq n 0 with
  | isTrue hn => rw [decide_eq_true hn]; exact Bool.false_le _
  | isFalse hn =>
    cases Nat.decEq m 0 with
    | isFalse hm => rw [decide_eq_false hm]; exact Bool.le_true _
    | isTrue hm => subst hm; 

Proof state:
case isFalse.isTrue
n : ℕ
hn : ¬n = 0
h : n ≤ 0
⊢ (!decide (n = 0)) ≤ !decide (0 = 0)

Next tactic:
have h := le_antisymm h (Nat.zero_le n)
theorem ofNat_le_ofNat {n m : Nat} (h : n ≤ m) : ofNat n ≤ ofNat m := by
  simp only [ofNat, ne_eq, _root_.decide_not]
  cases Nat.decEq n 0 with
  | isTrue hn => rw [decide_eq_true hn]; exact Bool.false_le _
  | isFalse hn =>
    cases Nat.decEq m 0 with
    | isFalse hm => rw [decide_eq_false hm]; exact Bool.le_true _
    | isTrue hm => subst hm; have h := le_antisymm h (Nat.zero_le n); 

Proof state:
case isFalse.isTrue
n : ℕ
hn : ¬n = 0
h✝ : n ≤ 0
h : n = 0
⊢ (!decide (n = 0)) ≤ !decide (0 = 0)

Next tactic:
contradiction