Theorem: project.findMin_is_minimum_head (Project/findMin.lean)

State before:
α : Type u_1
le : α → α → Bool
not_le_le : ∀ (x y : α), ¬le x y = true → le y x = true
le_trans : ∀ (x y z : α), le x y = true → le y z = true → le x z = true
le_rfl : ∀ (z : α), le z z = true
idx : ℕ
h' : BinTree α
idx' : ℕ
⊢ le (findMin le [] idx (h', idx')).fst.val h'.val = true
Tactic:
simp[findMin]
State after:
α : Type u_1
le : α → α → Bool
not_le_le : ∀ (x y : α), ¬le x y = true → le y x = true
le_trans : ∀ (x y z : α), le x y = true → le y z = true → le x z = true
le_rfl : ∀ (z : α), le z z = true
idx : ℕ
h' : BinTree α
idx' : ℕ
⊢ le h'.val h'.val = true

State before:
α : Type u_1
le : α → α → Bool
not_le_le : ∀ (x y : α), ¬le x y = true → le y x = true
le_trans : ∀ (x y z : α), le x y = true → le y z = true → le x z = true
le_rfl : ∀ (z : α), le z z = true
idx : ℕ
h' : BinTree α
idx' : ℕ
⊢ le h'.val h'.val = true
Tactic:
apply le_rfl
State after:
no goals

State before:
α : Type u_1
le : α → α → Bool
not_le_le : ∀ (x y : α), ¬le x y = true → le y x = true
le_trans : ∀ (x y z : α), le x y = true → le y z = true → le x z = true
le_rfl : ∀ (z : α), le z z = true
t : BinTree α
ts : List (BinTree α)
idx : ℕ
h' : BinTree α
idx' : ℕ
⊢ le (findMin le (t :: ts) idx (h', idx')).fst.val h'.val = true
Tactic:
unfold findMin
State after:
α : Type u_1
le : α → α → Bool
not_le_le : ∀ (x y : α), ¬le x y = true → le y x = true
le_trans : ∀ (x y z : α), le x y = true → le y z = true → le x z = true
le_rfl : ∀ (z : α), le z z = true
t : BinTree α
ts : List (BinTree α)
idx : ℕ
h' : BinTree α
idx' : ℕ
⊢ le (if le h'.val t.val = true then findMin le ts (idx + 1) (h', idx') else findMin le ts (idx + 1) (t, idx)).fst.val
      h'.val =
    true

State before:
α : Type u_1
le : α → α → Bool
not_le_le : ∀ (x y : α), ¬le x y = true → le y x = true
le_trans : ∀ (x y z : α), le x y = true → le y z = true → le x z = true
le_rfl : ∀ (z : α), le z z = true
t : BinTree α
ts : List (BinTree α)
idx : ℕ
h' : BinTree α
idx' : ℕ
⊢ le (if le h'.val t.val = true then findMin le ts (idx + 1) (h', idx') else findMin le ts (idx + 1) (t, idx)).fst.val
      h'.val =
    true
Tactic:
split
State after:
case inl
α : Type u_1
le : α → α → Bool
not_le_le : ∀ (x y : α), ¬le x y = true → le y x = true
le_trans : ∀ (x y z : α), le x y = true → le y z = true → le x z = true
le_rfl : ∀ (z : α), le z z = true
t : BinTree α
ts : List (BinTree α)
idx : ℕ
h' : BinTree α
idx' : ℕ
h✝ : le h'.val t.val = true
⊢ le (findMin le ts (idx + 1) (h', idx')).fst.val h'.val = true

case inr
α : Type u_1
le : α → α → Bool
not_le_le : ∀ (x y : α), ¬le x y = true → le y x = true
le_trans : ∀ (x y z : α), le x y = true → le y z = true → le x z = true
le_rfl : ∀ (z : α), le z z = true
t : BinTree α
ts : List (BinTree α)
idx : ℕ
h' : BinTree α
idx' : ℕ
h✝ : ¬le h'.val t.val = true
⊢ le (findMin le ts (idx + 1) (t, idx)).fst.val h'.val = true

State before:
case inl
α : Type u_1
le : α → α → Bool
not_le_le : ∀ (x y : α), ¬le x y = true → le y x = true
le_trans : ∀ (x y z : α), le x y = true → le y z = true → le x z = true
le_rfl : ∀ (z : α), le z z = true
t : BinTree α
ts : List (BinTree α)
idx : ℕ
h' : BinTree α
idx' : ℕ
h✝ : le h'.val t.val = true
⊢ le (findMin le ts (idx + 1) (h', idx')).fst.val h'.val = true

case inr
α : Type u_1
le : α → α → Bool
not_le_le : ∀ (x y : α), ¬le x y = true → le y x = true
le_trans : ∀ (x y z : α), le x y = true → le y z = true → le x z = true
le_rfl : ∀ (z : α), le z z = true
t : BinTree α
ts : List (BinTree α)
idx : ℕ
h' : BinTree α
idx' : ℕ
h✝ : ¬le h'.val t.val = true
⊢ le (findMin le ts (idx + 1) (t, idx)).fst.val h'.val = true
Tactic:
. apply findMin_is_minimum_head
State after:
case inr
α : Type u_1
le : α → α → Bool
not_le_le : ∀ (x y : α), ¬le x y = true → le y x = true
le_trans : ∀ (x y z : α), le x y = true → le y z = true → le x z = true
le_rfl : ∀ (z : α), le z z = true
t : BinTree α
ts : List (BinTree α)
idx : ℕ
h' : BinTree α
idx' : ℕ
h✝ : ¬le h'.val t.val = true
⊢ le (findMin le ts (idx + 1) (t, idx)).fst.val h'.val = true

State before:
case inr
α : Type u_1
le : α → α → Bool
not_le_le : ∀ (x y : α), ¬le x y = true → le y x = true
le_trans : ∀ (x y z : α), le x y = true → le y z = true → le x z = true
le_rfl : ∀ (z : α), le z z = true
t : BinTree α
ts : List (BinTree α)
idx : ℕ
h' : BinTree α
idx' : ℕ
h✝ : ¬le h'.val t.val = true
⊢ le (findMin le ts (idx + 1) (t, idx)).fst.val h'.val = true
Tactic:
. have ih := findMin_is_minimum_head ts (idx + 1) t idx
  apply le_trans
  assumption
  apply not_le_le
  assumption
State after:
no goals