internlm/Lean-Github huggingface dataset:
Theorem: project.IsMinHeap_eraseIdx
Proof state before:
case h_1
α : 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
b : List (HeapNodeAux α (Heap α))
t : BinTree α
ts : List (HeapNodeAux α (Heap α))
st : IsSearchTree le t
mh : IsMinHeap le (Heap.heap ts)
x✝² : ℕ
x✝¹ : List (HeapNodeAux α (Heap α))
x✝ : ℕ
heq✝ : t :: ts = []
⊢ IsMinHeap le (Heap.heap [])

case h_2
α : 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
b : List (HeapNodeAux α (Heap α))
t : BinTree α
ts : List (HeapNodeAux α (Heap α))
st : IsSearchTree le t
mh : IsMinHeap le (Heap.heap ts)
x✝¹ : List (HeapNodeAux α (Heap α))
x✝ : ℕ
head✝ : HeapNodeAux α (Heap α)
as✝ : List (HeapNodeAux α (Heap α))
heq✝ : t :: ts = head✝ :: as✝
⊢ IsMinHeap le (Heap.heap as✝)

case h_3
α : 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
b : List (HeapNodeAux α (Heap α))
t : BinTree α
ts : List (HeapNodeAux α (Heap α))
st : IsSearchTree le t
mh : IsMinHeap le (Heap.heap ts)
x✝¹ : List (HeapNodeAux α (Heap α))
x✝ : ℕ
a✝ : HeapNodeAux α (Heap α)
as✝ : List (HeapNodeAux α (Heap α))
n✝ : ℕ
heq✝ : t :: ts = a✝ :: as✝
⊢ IsMinHeap le (Heap.heap (a✝ :: List.eraseIdx as✝ n✝))
Tactic:
. constructor
Proof state after:
case h_2
α : 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
b : List (HeapNodeAux α (Heap α))
t : BinTree α
ts : List (HeapNodeAux α (Heap α))
st : IsSearchTree le t
mh : IsMinHeap le (Heap.heap ts)
x✝¹ : List (HeapNodeAux α (Heap α))
x✝ : ℕ
head✝ : HeapNodeAux α (Heap α)
as✝ : List (HeapNodeAux α (Heap α))
heq✝ : t :: ts = head✝ :: as✝
⊢ IsMinHeap le (Heap.heap as✝)

case h_3
α : 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
b : List (HeapNodeAux α (Heap α))
t : BinTree α
ts : List (HeapNodeAux α (Heap α))
st : IsSearchTree le t
mh : IsMinHeap le (Heap.heap ts)
x✝¹ : List (HeapNodeAux α (Heap α))
x✝ : ℕ
a✝ : HeapNodeAux α (Heap α)
as✝ : List (HeapNodeAux α (Heap α))
n✝ : ℕ
heq✝ : t :: ts = a✝ :: as✝
⊢ IsMinHeap le (Heap.heap (a✝ :: List.eraseIdx as✝ n✝))
Theorem: project.IsMinHeap_eraseIdx
Proof state before:
case h_2
α : 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
b : List (HeapNodeAux α (Heap α))
t : BinTree α
ts : List (HeapNodeAux α (Heap α))
st : IsSearchTree le t
mh : IsMinHeap le (Heap.heap ts)
x✝¹ : List (HeapNodeAux α (Heap α))
x✝ : ℕ
head✝ : HeapNodeAux α (Heap α)
as✝ : List (HeapNodeAux α (Heap α))
heq✝ : t :: ts = head✝ :: as✝
⊢ IsMinHeap le (Heap.heap as✝)

case h_3
α : 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
b : List (HeapNodeAux α (Heap α))
t : BinTree α
ts : List (HeapNodeAux α (Heap α))
st : IsSearchTree le t
mh : IsMinHeap le (Heap.heap ts)
x✝¹ : List (HeapNodeAux α (Heap α))
x✝ : ℕ
a✝ : HeapNodeAux α (Heap α)
as✝ : List (HeapNodeAux α (Heap α))
n✝ : ℕ
heq✝ : t :: ts = a✝ :: as✝
⊢ IsMinHeap le (Heap.heap (a✝ :: List.eraseIdx as✝ n✝))
Tactic:
. rename_i heq
  rw[← List.tail_eq_of_cons_eq heq]
  assumption
Proof state after:
case h_3
α : 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
b : List (HeapNodeAux α (Heap α))
t : BinTree α
ts : List (HeapNodeAux α (Heap α))
st : IsSearchTree le t
mh : IsMinHeap le (Heap.heap ts)
x✝¹ : List (HeapNodeAux α (Heap α))
x✝ : ℕ
a✝ : HeapNodeAux α (Heap α)
as✝ : List (HeapNodeAux α (Heap α))
n✝ : ℕ
heq✝ : t :: ts = a✝ :: as✝
⊢ IsMinHeap le (Heap.heap (a✝ :: List.eraseIdx as✝ n✝))
Theorem: project.IsMinHeap_eraseIdx
Proof state before:
case h_3
α : 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
b : List (HeapNodeAux α (Heap α))
t : BinTree α
ts : List (HeapNodeAux α (Heap α))
st : IsSearchTree le t
mh : IsMinHeap le (Heap.heap ts)
x✝¹ : List (HeapNodeAux α (Heap α))
x✝ : ℕ
a✝ : HeapNodeAux α (Heap α)
as✝ : List (HeapNodeAux α (Heap α))
n✝ : ℕ
heq✝ : t :: ts = a✝ :: as✝
⊢ IsMinHeap le (Heap.heap (a✝ :: List.eraseIdx as✝ n✝))
Tactic:
. rename_i heq
  constructor
  . rw[← List.head_eq_of_cons_eq heq]
    assumption
  . apply IsMinHeap_eraseIdx
    rw[← List.tail_eq_of_cons_eq heq]
    assumption
Proof state after:
no goals
Theorem: project.IsMinHeap_delete_BinTree
Proof 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
a : HeapNodeAux α (Heap α)
b : List (HeapNodeAux α (Heap α))
id : ℕ
⊢ IsMinHeap le (Heap.heap (a :: b)) → IsMinHeap le (Heap.heap (a :: List.eraseIdx b id))
Tactic:
intros imh
Proof 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
a : HeapNodeAux α (Heap α)
b : List (HeapNodeAux α (Heap α))
id : ℕ
imh : IsMinHeap le (Heap.heap (a :: b))
⊢ IsMinHeap le (Heap.heap (a :: List.eraseIdx b id))
Theorem: project.IsMinHeap_delete_BinTree
Proof 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
a : HeapNodeAux α (Heap α)
b : List (HeapNodeAux α (Heap α))
id : ℕ
imh : IsMinHeap le (Heap.heap (a :: b))
⊢ IsMinHeap le (Heap.heap (a :: List.eraseIdx b id))
Tactic:
cases imh
Proof state after:
case cons
α : 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
a : HeapNodeAux α (Heap α)
b : List (HeapNodeAux α (Heap α))
id : ℕ
a✝¹ : IsSearchTree le a
a✝ : IsMinHeap le (Heap.heap b)
⊢ IsMinHeap le (Heap.heap (a :: List.eraseIdx b id))
Theorem: project.IsMinHeap_delete_BinTree
Proof state before:
case cons
α : 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
a : HeapNodeAux α (Heap α)
b : List (HeapNodeAux α (Heap α))
id : ℕ
a✝¹ : IsSearchTree le a
a✝ : IsMinHeap le (Heap.heap b)
⊢ IsMinHeap le (Heap.heap (a :: List.eraseIdx b id))
Tactic:
constructor
Proof state after:
case cons.a
α : 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
a : HeapNodeAux α (Heap α)
b : List (HeapNodeAux α (Heap α))
id : ℕ
a✝¹ : IsSearchTree le a
a✝ : IsMinHeap le (Heap.heap b)
⊢ IsSearchTree le a

case cons.a
α : 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
a : HeapNodeAux α (Heap α)
b : List (HeapNodeAux α (Heap α))
id : ℕ
a✝¹ : IsSearchTree le a
a✝ : IsMinHeap le (Heap.heap b)
⊢ IsMinHeap le (Heap.heap (List.eraseIdx b id))
Theorem: project.IsMinHeap_delete_BinTree
Proof state before:
case cons.a
α : 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
a : HeapNodeAux α (Heap α)
b : List (HeapNodeAux α (Heap α))
id : ℕ
a✝¹ : IsSearchTree le a
a✝ : IsMinHeap le (Heap.heap b)
⊢ IsSearchTree le a

case cons.a
α : 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
a : HeapNodeAux α (Heap α)
b : List (HeapNodeAux α (Heap α))
id : ℕ
a✝¹ : IsSearchTree le a
a✝ : IsMinHeap le (Heap.heap b)
⊢ IsMinHeap le (Heap.heap (List.eraseIdx b id))
Tactic:
. assumption
Proof state after:
case cons.a
α : 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
a : HeapNodeAux α (Heap α)
b : List (HeapNodeAux α (Heap α))
id : ℕ
a✝¹ : IsSearchTree le a
a✝ : IsMinHeap le (Heap.heap b)
⊢ IsMinHeap le (Heap.heap (List.eraseIdx b id))
Theorem: project.IsMinHeap_delete_BinTree
Proof state before:
case cons.a
α : 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
a : HeapNodeAux α (Heap α)
b : List (HeapNodeAux α (Heap α))
id : ℕ
a✝¹ : IsSearchTree le a
a✝ : IsMinHeap le (Heap.heap b)
⊢ IsMinHeap le (Heap.heap (List.eraseIdx b id))
Tactic:
. apply IsMinHeap_eraseIdx
  assumption
Proof state after:
no goals
Theorem: project.rank_zero_IsRankedTree
Proof state before:
α : Sort ?u.123130
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
n : ℕ
α✝ : Type u_1
ts✝ ts : List (BinTree α✝)
t✝ : BinTree α✝
a✝¹ : t✝.rank = n + 1
rt : IsRankedTree (n + 1 + 1) 0 ts
a✝ : IsBinTree t✝
⊢ False
Tactic:
cases rt with
| cons => 
  apply rank_zero_IsRankedTree
  assumption
Proof state after:
no goals
Theorem: project.rank_zero_IsRankedTree
Proof state before:
case cons
α : Sort ?u.123130
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
n : ℕ
α✝ : Type u_1
ts : List (BinTree α✝)
t✝¹ : BinTree α✝
a✝⁴ : t✝¹.rank = n + 1
a✝³ : IsBinTree t✝¹
ts✝ : List (BinTree α✝)
t✝ : BinTree α✝
a✝² : IsBinTree t✝
a✝¹ : t✝.rank = n + 1 + 1
a✝ : IsRankedTree (n + 1 + 1 + 1) 0 ts✝
⊢ False
Tactic:
apply rank_zero_IsRankedTree
Proof state after:
case cons.a
α : Sort ?u.123130
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
n : ℕ
α✝ : Type u_1
ts : List (BinTree α✝)
t✝¹ : BinTree α✝
a✝⁴ : t✝¹.rank = n + 1
a✝³ : IsBinTree t✝¹
ts✝ : List (BinTree α✝)
t✝ : BinTree α✝
a✝² : IsBinTree t✝
a✝¹ : t✝.rank = n + 1 + 1
a✝ : IsRankedTree (n + 1 + 1 + 1) 0 ts✝
⊢ IsRankedTree (?cons.n + 1) 0 ?cons.ts

case cons.n
α : Sort ?u.123130
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
n : ℕ
α✝ : Type u_1
ts : List (BinTree α✝)
t✝¹ : BinTree α✝
a✝⁴ : t✝¹.rank = n + 1
a✝³ : IsBinTree t✝¹
ts✝ : List (BinTree α✝)
t✝ : BinTree α✝
a✝² : IsBinTree t✝
a✝¹ : t✝.rank = n + 1 + 1
a✝ : IsRankedTree (n + 1 + 1 + 1) 0 ts✝
⊢ ℕ

case cons.α
α : Sort ?u.123130
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
n : ℕ
α✝ : Type u_1
ts : List (BinTree α✝)
t✝¹ : BinTree α✝
a✝⁴ : t✝¹.rank = n + 1
a✝³ : IsBinTree t✝¹
ts✝ : List (BinTree α✝)
t✝ : BinTree α✝
a✝² : IsBinTree t✝
a✝¹ : t✝.rank = n + 1 + 1
a✝ : IsRankedTree (n + 1 + 1 + 1) 0 ts✝
⊢ Type u_1

case cons.ts
α : Sort ?u.123130
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
n : ℕ
α✝ : Type u_1
ts : List (BinTree α✝)
t✝¹ : BinTree α✝
a✝⁴ : t✝¹.rank = n + 1
a✝³ : IsBinTree t✝¹
ts✝ : List (BinTree α✝)
t✝ : BinTree α✝
a✝² : IsBinTree t✝
a✝¹ : t✝.rank = n + 1 + 1
a✝ : IsRankedTree (n + 1 + 1 + 1) 0 ts✝
⊢ List (BinTree ?cons.α)
Theorem: project.rank_zero_IsRankedTree
Proof state before:
case cons.a
α : Sort ?u.123130
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
n : ℕ
α✝ : Type u_1
ts : List (BinTree α✝)
t✝¹ : BinTree α✝
a✝⁴ : t✝¹.rank = n + 1
a✝³ : IsBinTree t✝¹
ts✝ : List (BinTree α✝)
t✝ : BinTree α✝
a✝² : IsBinTree t✝
a✝¹ : t✝.rank = n + 1 + 1
a✝ : IsRankedTree (n + 1 + 1 + 1) 0 ts✝
⊢ IsRankedTree (?cons.n + 1) 0 ?cons.ts

case cons.n
α : Sort ?u.123130
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
n : ℕ
α✝ : Type u_1
ts : List (BinTree α✝)
t✝¹ : BinTree α✝
a✝⁴ : t✝¹.rank = n + 1
a✝³ : IsBinTree t✝¹
ts✝ : List (BinTree α✝)
t✝ : BinTree α✝
a✝² : IsBinTree t✝
a✝¹ : t✝.rank = n + 1 + 1
a✝ : IsRankedTree (n + 1 + 1 + 1) 0 ts✝
⊢ ℕ

case cons.α
α : Sort ?u.123130
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
n : ℕ
α✝ : Type u_1
ts : List (BinTree α✝)
t✝¹ : BinTree α✝
a✝⁴ : t✝¹.rank = n + 1
a✝³ : IsBinTree t✝¹
ts✝ : List (BinTree α✝)
t✝ : BinTree α✝
a✝² : IsBinTree t✝
a✝¹ : t✝.rank = n + 1 + 1
a✝ : IsRankedTree (n + 1 + 1 + 1) 0 ts✝
⊢ Type u_1

case cons.ts
α : Sort ?u.123130
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
n : ℕ
α✝ : Type u_1
ts : List (BinTree α✝)
t✝¹ : BinTree α✝
a✝⁴ : t✝¹.rank = n + 1
a✝³ : IsBinTree t✝¹
ts✝ : List (BinTree α✝)
t✝ : BinTree α✝
a✝² : IsBinTree t✝
a✝¹ : t✝.rank = n + 1 + 1
a✝ : IsRankedTree (n + 1 + 1 + 1) 0 ts✝
⊢ List (BinTree ?cons.α)
Tactic:
assumption
Proof state after:
no goals
Theorem: project.min_rank_IsBinTree
Proof 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
Proof 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
Theorem: project.min_rank_IsBinTree
Proof 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
Proof state after:
no goals
Theorem: project.min_rank_IsBinTree
Proof 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
Proof 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
Theorem: project.min_rank_IsBinTree
Proof 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
Proof 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
Theorem: project.min_rank_IsBinTree
Proof 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
Proof state after:
no goals
Theorem: project.min_rank_IsBinTree
Proof 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
Proof 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
Theorem: project.min_rank_IsBinTree
Proof 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
Proof 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
Theorem: project.min_rank_IsBinTree
Proof 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
Proof 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
Theorem: project.min_rank_IsBinTree
Proof 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
Proof 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
Theorem: project.min_rank_IsBinTree
Proof 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
Proof state after:
no goals
Theorem: project.deleteMin_non_empty_minimum
Proof 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
xs : List (HeapNodeAux α (Heap α))
y : α
ys : Heap α
⊢ deleteMin le (Heap.heap xs) = some (y, ys) → ∀ (x : HeapNodeAux α (Heap α)), x ∈ xs → le y x.val = true
Tactic:
intros heq t hel
Proof 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
xs : List (HeapNodeAux α (Heap α))
y : α
ys : Heap α
heq : deleteMin le (Heap.heap xs) = some (y, ys)
t : HeapNodeAux α (Heap α)
hel : t ∈ xs
⊢ le y t.val = true