Theorem: project.min_rank_IsBinTree (Project/DeleteMin.lean)

State before:
α : Sort ?u.144314
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
α✝ : Type u_1
t : BinTree α✝
⊢ IsBinTree t → 0 < t.rank
Tactic:
intro bt
State after:
α : Sort ?u.144314
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
α✝ : Type u_1
t : BinTree α✝
bt : IsBinTree t
⊢ 0 < t.rank

State before:
α : Sort ?u.144314
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
α✝ : Type u_1
t : BinTree α✝
bt : IsBinTree t
⊢ 0 < t.rank
Tactic:
cases t with | mk val r children =>
cases r
. cases bt with | mk rt =>
  simp at rt
  generalize eq : (children.nodes) = ts
  rw[eq] at rt
  cases rt
  . simp
    apply rank_zero_IsRankedTree
    assumption
. simp_arith
State after:
no goals

State before:
case mk
α : Sort ?u.144314
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
α✝ : Type u_1
val : α✝
r : ℕ
children : Heap α✝
bt : IsBinTree { val := val, rank := r, children := children }
⊢ 0 < { val := val, rank := r, children := children }.rank
Tactic:
cases r
State after:
case mk.zero
α : Sort ?u.144314
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
α✝ : Type u_1
val : α✝
children : Heap α✝
bt : IsBinTree { val := val, rank := Nat.zero, children := children }
⊢ 0 < { val := val, rank := Nat.zero, children := children }.rank

case mk.succ
α : Sort ?u.144314
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
α✝ : Type u_1
val : α✝
children : Heap α✝
n✝ : ℕ
bt : IsBinTree { val := val, rank := Nat.succ n✝, children := children }
⊢ 0 < { val := val, rank := Nat.succ n✝, children := children }.rank

State before:
case mk.zero
α : Sort ?u.144314
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
α✝ : Type u_1
val : α✝
children : Heap α✝
bt : IsBinTree { val := val, rank := Nat.zero, children := children }
⊢ 0 < { val := val, rank := Nat.zero, children := children }.rank

case mk.succ
α : Sort ?u.144314
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
α✝ : Type u_1
val : α✝
children : Heap α✝
n✝ : ℕ
bt : IsBinTree { val := val, rank := Nat.succ n✝, children := children }
⊢ 0 < { val := val, rank := Nat.succ n✝, children := children }.rank
Tactic:
. cases bt with | mk rt =>
  simp at rt
  generalize eq : (children.nodes) = ts
  rw[eq] at rt
  cases rt
  . simp
    apply rank_zero_IsRankedTree
    assumption
State after:
case mk.succ
α : Sort ?u.144314
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
α✝ : Type u_1
val : α✝
children : Heap α✝
n✝ : ℕ
bt : IsBinTree { val := val, rank := Nat.succ n✝, children := children }
⊢ 0 < { val := val, rank := Nat.succ n✝, children := children }.rank

State before:
case mk.succ
α : Sort ?u.144314
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
α✝ : Type u_1
val : α✝
children : Heap α✝
n✝ : ℕ
bt : IsBinTree { val := val, rank := Nat.succ n✝, children := children }
⊢ 0 < { val := val, rank := Nat.succ n✝, children := children }.rank
Tactic:
. simp_arith
State after:
no goals

State before:
case mk.zero.mk
α : Sort ?u.144314
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
α✝ : Type u_1
val : α✝
children : Heap α✝
rt :
  IsRankedTree 1 { val := val, rank := Nat.zero, children := children }.rank
    (Heap.nodes { val := val, rank := Nat.zero, children := children }.children)
⊢ 0 < { val := val, rank := Nat.zero, children := children }.rank
Tactic:
simp at rt
State after:
case mk.zero.mk
α : Sort ?u.144314
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
α✝ : Type u_1
val : α✝
children : Heap α✝
rt : IsRankedTree 1 0 (Heap.nodes children)
⊢ 0 < { val := val, rank := Nat.zero, children := children }.rank

State before:
case mk.zero.mk
α : Sort ?u.144314
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
α✝ : Type u_1
val : α✝
children : Heap α✝
rt : IsRankedTree 1 0 (Heap.nodes children)
⊢ 0 < { val := val, rank := Nat.zero, children := children }.rank
Tactic:
generalize eq : (children.nodes) = ts
State after:
case mk.zero.mk
α : Sort ?u.144314
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
α✝ : Type u_1
val : α✝
children : Heap α✝
rt : IsRankedTree 1 0 (Heap.nodes children)
ts : List (BinTree α✝)
eq : Heap.nodes children = ts
⊢ 0 < { val := val, rank := Nat.zero, children := children }.rank

State before:
case mk.zero.mk
α : Sort ?u.144314
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
α✝ : Type u_1
val : α✝
children : Heap α✝
rt : IsRankedTree 1 0 (Heap.nodes children)
ts : List (BinTree α✝)
eq : Heap.nodes children = ts
⊢ 0 < { val := val, rank := Nat.zero, children := children }.rank
Tactic:
rw[eq] at rt
State after:
case mk.zero.mk
α : Sort ?u.144314
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
α✝ : Type u_1
val : α✝
children : Heap α✝
ts : List (BinTree α✝)
rt : IsRankedTree 1 0 ts
eq : Heap.nodes children = ts
⊢ 0 < { val := val, rank := Nat.zero, children := children }.rank

State before:
case mk.zero.mk
α : Sort ?u.144314
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
α✝ : Type u_1
val : α✝
children : Heap α✝
ts : List (BinTree α✝)
rt : IsRankedTree 1 0 ts
eq : Heap.nodes children = ts
⊢ 0 < { val := val, rank := Nat.zero, children := children }.rank
Tactic:
cases rt
State after:
case mk.zero.mk.cons
α : Sort ?u.144314
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
α✝ : Type u_1
val : α✝
children : Heap α✝
ts✝ : List (BinTree α✝)
t✝ : BinTree α✝
a✝² : IsBinTree t✝
a✝¹ : t✝.rank = 1
a✝ : IsRankedTree (1 + 1) 0 ts✝
eq : Heap.nodes children = t✝ :: ts✝
⊢ 0 < { val := val, rank := Nat.zero, children := children }.rank

State before:
case mk.zero.mk.cons
α : Sort ?u.144314
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
α✝ : Type u_1
val : α✝
children : Heap α✝
ts✝ : List (BinTree α✝)
t✝ : BinTree α✝
a✝² : IsBinTree t✝
a✝¹ : t✝.rank = 1
a✝ : IsRankedTree (1 + 1) 0 ts✝
eq : Heap.nodes children = t✝ :: ts✝
⊢ 0 < { val := val, rank := Nat.zero, children := children }.rank
Tactic:
. simp
  apply rank_zero_IsRankedTree
  assumption
State after:
no goals