Theorem: Batteries.BinomialHeap.Imp.Heap.realSize_findMin
File: .lake/packages/batteries/Batteries/Data/BinomialHeap/Basic.lean

tactic: simp [findMin]
state_before: α : Type u_1
k : Heap α → Heap α
n : Nat
le : α → α → Bool
res : FindMin α
s✝ : Heap α
m : Nat
hk : ∀ (s : Heap α), (k s).realSize = m + s.realSize
hres : Batteries.BinomialHeap.Imp.FindMin.HasSize res n
r : Nat
a : α
c : HeapNode α
s : Heap α
eq : n = m + (cons r a c s).realSize
⊢ Batteries.BinomialHeap.Imp.FindMin.HasSize (findMin le k (cons r a c s) res) n
state_after: α : Type u_1
k : Heap α → Heap α
n : Nat
le : α → α → Bool
res : FindMin α
s✝ : Heap α
m : Nat
hk : ∀ (s : Heap α), (k s).realSize = m + s.realSize
hres : Batteries.BinomialHeap.Imp.FindMin.HasSize res n
r : Nat
a : α
c : HeapNode α
s : Heap α
eq : n = m + (cons r a c s).realSize
⊢ Batteries.BinomialHeap.Imp.FindMin.HasSize
    (findMin le (k ∘ cons r a c) s
      (if le res.val a = true then res else { before := k, val := a, node := c, next := s }))
    n

tactic: refine realSize_findMin (m + c.realSize + 1)
  (by simp [hk, Nat.add_assoc]) (by simp [eq, Nat.add_assoc]) ?_
state_before: α : Type u_1
k : Heap α → Heap α
n : Nat
le : α → α → Bool
res : FindMin α
s✝ : Heap α
m : Nat
hk : ∀ (s : Heap α), (k s).realSize = m + s.realSize
hres : Batteries.BinomialHeap.Imp.FindMin.HasSize res n
r : Nat
a : α
c : HeapNode α
s : Heap α
eq : n = m + (cons r a c s).realSize
⊢ Batteries.BinomialHeap.Imp.FindMin.HasSize
    (findMin le (k ∘ cons r a c) s
      (if le res.val a = true then res else { before := k, val := a, node := c, next := s }))
    n
state_after: α : Type u_1
k : Heap α → Heap α
n : Nat
le : α → α → Bool
res : FindMin α
s✝ : Heap α
m : Nat
hk : ∀ (s : Heap α), (k s).realSize = m + s.realSize
hres : Batteries.BinomialHeap.Imp.FindMin.HasSize res n
r : Nat
a : α
c : HeapNode α
s : Heap α
eq : n = m + (cons r a c s).realSize
⊢ Batteries.BinomialHeap.Imp.FindMin.HasSize
    (if le res.val a = true then res else { before := k, val := a, node := c, next := s }) n

tactic: split
state_before: α : Type u_1
k : Heap α → Heap α
n : Nat
le : α → α → Bool
res : FindMin α
s✝ : Heap α
m : Nat
hk : ∀ (s : Heap α), (k s).realSize = m + s.realSize
hres : Batteries.BinomialHeap.Imp.FindMin.HasSize res n
r : Nat
a : α
c : HeapNode α
s : Heap α
eq : n = m + (cons r a c s).realSize
⊢ Batteries.BinomialHeap.Imp.FindMin.HasSize
    (if le res.val a = true then res else { before := k, val := a, node := c, next := s }) n
state_after: case isTrue
α : Type u_1
k : Heap α → Heap α
n : Nat
le : α → α → Bool
res : FindMin α
s✝ : Heap α
m : Nat
hk : ∀ (s : Heap α), (k s).realSize = m + s.realSize
hres : Batteries.BinomialHeap.Imp.FindMin.HasSize res n
r : Nat
a : α
c : HeapNode α
s : Heap α
eq : n = m + (cons r a c s).realSize
h✝ : le res.val a = true
⊢ Batteries.BinomialHeap.Imp.FindMin.HasSize res n

case isFalse
α : Type u_1
k : Heap α → Heap α
n : Nat
le : α → α → Bool
res : FindMin α
s✝ : Heap α
m : Nat
hk : ∀ (s : Heap α), (k s).realSize = m + s.realSize
hres : Batteries.BinomialHeap.Imp.FindMin.HasSize res n
r : Nat
a : α
c : HeapNode α
s : Heap α
eq : n = m + (cons r a c s).realSize
h✝ : ¬le res.val a = true
⊢ Batteries.BinomialHeap.Imp.FindMin.HasSize { before := k, val := a, node := c, next := s } n

tactic: simp [hk, Nat.add_assoc]
state_before: α : Type u_1
k : Heap α → Heap α
n : Nat
le : α → α → Bool
res : FindMin α
s✝ : Heap α
m : Nat
hk : ∀ (s : Heap α), (k s).realSize = m + s.realSize
hres : Batteries.BinomialHeap.Imp.FindMin.HasSize res n
r : Nat
a : α
c : HeapNode α
s : Heap α
eq : n = m + (cons r a c s).realSize
⊢ ∀ (s : Heap α), ((k ∘ cons r a c) s).realSize = m + c.realSize + 1 + s.realSize
state_after: no goals

tactic: simp [eq, Nat.add_assoc]
state_before: α : Type u_1
k : Heap α → Heap α
n : Nat
le : α → α → Bool
res : FindMin α
s✝ : Heap α
m : Nat
hk : ∀ (s : Heap α), (k s).realSize = m + s.realSize
hres : Batteries.BinomialHeap.Imp.FindMin.HasSize res n
r : Nat
a : α
c : HeapNode α
s : Heap α
eq : n = m + (cons r a c s).realSize
⊢ n = m + c.realSize + 1 + s.realSize
state_after: no goals

tactic: exact hres
state_before: case isTrue
α : Type u_1
k : Heap α → Heap α
n : Nat
le : α → α → Bool
res : FindMin α
s✝ : Heap α
m : Nat
hk : ∀ (s : Heap α), (k s).realSize = m + s.realSize
hres : Batteries.BinomialHeap.Imp.FindMin.HasSize res n
r : Nat
a : α
c : HeapNode α
s : Heap α
eq : n = m + (cons r a c s).realSize
h✝ : le res.val a = true
⊢ Batteries.BinomialHeap.Imp.FindMin.HasSize res n
state_after: no goals

tactic: exact ⟨m, hk, by simp [eq, Nat.add_assoc, Nat.add_comm, Nat.add_left_comm]⟩
state_before: case isFalse
α : Type u_1
k : Heap α → Heap α
n : Nat
le : α → α → Bool
res : FindMin α
s✝ : Heap α
m : Nat
hk : ∀ (s : Heap α), (k s).realSize = m + s.realSize
hres : Batteries.BinomialHeap.Imp.FindMin.HasSize res n
r : Nat
a : α
c : HeapNode α
s : Heap α
eq : n = m + (cons r a c s).realSize
h✝ : ¬le res.val a = true
⊢ Batteries.BinomialHeap.Imp.FindMin.HasSize { before := k, val := a, node := c, next := s } n
state_after: no goals

tactic: simp [eq, Nat.add_assoc, Nat.add_comm, Nat.add_left_comm]
state_before: α : Type u_1
k : Heap α → Heap α
n : Nat
le : α → α → Bool
res : FindMin α
s✝ : Heap α
m : Nat
hk : ∀ (s : Heap α), (k s).realSize = m + s.realSize
hres : Batteries.BinomialHeap.Imp.FindMin.HasSize res n
r : Nat
a : α
c : HeapNode α
s : Heap α
eq : n = m + (cons r a c s).realSize
h✝ : ¬le res.val a = true
⊢ n =
    m + { before := k, val := a, node := c, next := s }.node.realSize +
        { before := k, val := a, node := c, next := s }.next.realSize +
      1
state_after: no goals