Theorem: project.IsHeapForest'_of_IsRankedTree (Project/DeleteMin.lean)

State before:
α : Sort ?u.894
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
r s : ℕ
α✝ : Type u_1
nodes : List (BinTree α✝)
h₁ : r ≠ 0
⊢ IsHeapForest' (r - 1) []
Tactic:
constructor
State after:
no goals

State before:
α : Sort ?u.894
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
r s✝ : ℕ
α✝ : Type u_1
nodes : List (BinTree α✝)
h₁ : r ≠ 0
s : ℕ
ts : List (BinTree α✝)
t : BinTree α✝
eq : t.rank = r
rt : IsRankedTree (r + 1) s ts
a✝ : IsBinTree t
⊢ IsHeapForest' (r - 1) (t :: ts)
Tactic:
constructor
State after:
case a
α : Sort ?u.894
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
r s✝ : ℕ
α✝ : Type u_1
nodes : List (BinTree α✝)
h₁ : r ≠ 0
s : ℕ
ts : List (BinTree α✝)
t : BinTree α✝
eq : t.rank = r
rt : IsRankedTree (r + 1) s ts
a✝ : IsBinTree t
⊢ r - 1 < t.rank

case a
α : Sort ?u.894
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
r s✝ : ℕ
α✝ : Type u_1
nodes : List (BinTree α✝)
h₁ : r ≠ 0
s : ℕ
ts : List (BinTree α✝)
t : BinTree α✝
eq : t.rank = r
rt : IsRankedTree (r + 1) s ts
a✝ : IsBinTree t
⊢ IsBinTree t

case a
α : Sort ?u.894
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
r s✝ : ℕ
α✝ : Type u_1
nodes : List (BinTree α✝)
h₁ : r ≠ 0
s : ℕ
ts : List (BinTree α✝)
t : BinTree α✝
eq : t.rank = r
rt : IsRankedTree (r + 1) s ts
a✝ : IsBinTree t
⊢ IsHeapForest' t.rank ts

State before:
case a
α : Sort ?u.894
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
r s✝ : ℕ
α✝ : Type u_1
nodes : List (BinTree α✝)
h₁ : r ≠ 0
s : ℕ
ts : List (BinTree α✝)
t : BinTree α✝
eq : t.rank = r
rt : IsRankedTree (r + 1) s ts
a✝ : IsBinTree t
⊢ r - 1 < t.rank

case a
α : Sort ?u.894
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
r s✝ : ℕ
α✝ : Type u_1
nodes : List (BinTree α✝)
h₁ : r ≠ 0
s : ℕ
ts : List (BinTree α✝)
t : BinTree α✝
eq : t.rank = r
rt : IsRankedTree (r + 1) s ts
a✝ : IsBinTree t
⊢ IsBinTree t

case a
α : Sort ?u.894
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
r s✝ : ℕ
α✝ : Type u_1
nodes : List (BinTree α✝)
h₁ : r ≠ 0
s : ℕ
ts : List (BinTree α✝)
t : BinTree α✝
eq : t.rank = r
rt : IsRankedTree (r + 1) s ts
a✝ : IsBinTree t
⊢ IsHeapForest' t.rank ts
Tactic:
. rw[←eq]
  apply Nat.pred_lt
  simp
  rw[eq]
  assumption
State after:
case a
α : Sort ?u.894
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
r s✝ : ℕ
α✝ : Type u_1
nodes : List (BinTree α✝)
h₁ : r ≠ 0
s : ℕ
ts : List (BinTree α✝)
t : BinTree α✝
eq : t.rank = r
rt : IsRankedTree (r + 1) s ts
a✝ : IsBinTree t
⊢ IsBinTree t

case a
α : Sort ?u.894
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
r s✝ : ℕ
α✝ : Type u_1
nodes : List (BinTree α✝)
h₁ : r ≠ 0
s : ℕ
ts : List (BinTree α✝)
t : BinTree α✝
eq : t.rank = r
rt : IsRankedTree (r + 1) s ts
a✝ : IsBinTree t
⊢ IsHeapForest' t.rank ts

State before:
case a
α : Sort ?u.894
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
r s✝ : ℕ
α✝ : Type u_1
nodes : List (BinTree α✝)
h₁ : r ≠ 0
s : ℕ
ts : List (BinTree α✝)
t : BinTree α✝
eq : t.rank = r
rt : IsRankedTree (r + 1) s ts
a✝ : IsBinTree t
⊢ IsBinTree t

case a
α : Sort ?u.894
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
r s✝ : ℕ
α✝ : Type u_1
nodes : List (BinTree α✝)
h₁ : r ≠ 0
s : ℕ
ts : List (BinTree α✝)
t : BinTree α✝
eq : t.rank = r
rt : IsRankedTree (r + 1) s ts
a✝ : IsBinTree t
⊢ IsHeapForest' t.rank ts
Tactic:
. assumption
State after:
case a
α : Sort ?u.894
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
r s✝ : ℕ
α✝ : Type u_1
nodes : List (BinTree α✝)
h₁ : r ≠ 0
s : ℕ
ts : List (BinTree α✝)
t : BinTree α✝
eq : t.rank = r
rt : IsRankedTree (r + 1) s ts
a✝ : IsBinTree t
⊢ IsHeapForest' t.rank ts

State before:
case a
α : Sort ?u.894
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
r s✝ : ℕ
α✝ : Type u_1
nodes : List (BinTree α✝)
h₁ : r ≠ 0
s : ℕ
ts : List (BinTree α✝)
t : BinTree α✝
eq : t.rank = r
rt : IsRankedTree (r + 1) s ts
a✝ : IsBinTree t
⊢ IsHeapForest' t.rank ts
Tactic:
. have : t.rank = (r + 1) - 1 := by
    simp_all
  rw[this]
  apply IsHeapForest'_of_IsRankedTree
  . simp
  . assumption
State after:
no goals

State before:
α : Sort ?u.894
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
r s✝ : ℕ
α✝ : Type u_1
nodes : List (BinTree α✝)
h₁ : r ≠ 0
s : ℕ
ts : List (BinTree α✝)
t : BinTree α✝
eq : t.rank = r
rt : IsRankedTree (r + 1) s ts
a✝ : IsBinTree t
⊢ t.rank = r + 1 - 1
Tactic:
simp_all
State after:
no goals