Theorem: Std.BinomialHeapImp.Heap.realSize_merge
File: Std/Data/BinomialHeap.lean

tactic: unfold merge
state_before: α : Type u_1
le : α → α → Bool
s₁ s₂ : Heap α
⊢ realSize (merge le s₁ s₂) = realSize s₁ + realSize s₂

tactic: split
state_before: α : Type u_1
le : α → α → Bool
s₁ s₂ : Heap α
⊢ realSize
      (match s₁, s₂ with
      | nil, h => h
      | h, nil => h
      | s₁@h:(cons r₁ a₁ n₁ t₁), s₂@h_1:(cons r₂ a₂ n₂ t₂) =>
        if r₁ < r₂ then cons r₁ a₁ n₁ (merge le t₁ s₂)
        else
          if r₂ < r₁ then cons r₂ a₂ n₂ (merge le s₁ t₂)
          else
            match combine le a₁ a₂ n₁ n₂ with
            | (a, n) =>
              let r := r₁ + 1;
              if rankGT t₁ r then if rankGT t₂ r then cons r a n (merge le t₁ t₂) else merge le (cons r a n t₁) t₂
              else if rankGT t₂ r then merge le t₁ (cons r a n t₂) else cons r a n (merge le t₁ t₂)) =
    realSize s₁ + realSize s₂

tactic: simp
state_before: case h_1
α : Type u_1
le : α → α → Bool
s₂ x✝¹ x✝ : Heap α
⊢ realSize s₂ = realSize nil + realSize s₂

tactic: simp
state_before: case h_2
α : Type u_1
le : α → α → Bool
s₁ x✝² x✝¹ : Heap α
x✝ : s₁ = nil → False
⊢ realSize s₁ = realSize s₁ + realSize nil

tactic: rename_i r₁ a₁ n₁ t₁ r₂ a₂ n₂ t₂
state_before: case h_3
α : Type u_1
le : α → α → Bool
x✝¹ x✝ : Heap α
r₁✝ : Nat
a₁✝ : α
n₁✝ : HeapNode α
t₁✝ : Heap α
r₂✝ : Nat
a₂✝ : α
n₂✝ : HeapNode α
t₂✝ : Heap α
⊢ realSize
      (if r₁✝ < r₂✝ then cons r₁✝ a₁✝ n₁✝ (merge le t₁✝ (cons r₂✝ a₂✝ n₂✝ t₂✝))
      else
        if r₂✝ < r₁✝ then cons r₂✝ a₂✝ n₂✝ (merge le (cons r₁✝ a₁✝ n₁✝ t₁✝) t₂✝)
        else
          match combine le a₁✝ a₂✝ n₁✝ n₂✝ with
          | (a, n) =>
            let r := r₁✝ + 1;
            if rankGT t₁✝ r then if rankGT t₂✝ r then cons r a n (merge le t₁✝ t₂✝) else merge le (cons r a n t₁✝) t₂✝
            else if rankGT t₂✝ r then merge le t₁✝ (cons r a n t₂✝) else cons r a n (merge le t₁✝ t₂✝)) =
    realSize (cons r₁✝ a₁✝ n₁✝ t₁✝) + realSize (cons r₂✝ a₂✝ n₂✝ t₂✝)

tactic: have IH₁ r a n := realSize_merge le t₁ (cons r a n t₂)
state_before: case h_3
α : Type u_1
le : α → α → Bool
x✝¹ x✝ : Heap α
r₁ : Nat
a₁ : α
n₁ : HeapNode α
t₁ : Heap α
r₂ : Nat
a₂ : α
n₂ : HeapNode α
t₂ : Heap α
⊢ realSize
      (if r₁ < r₂ then cons r₁ a₁ n₁ (merge le t₁ (cons r₂ a₂ n₂ t₂))
      else
        if r₂ < r₁ then cons r₂ a₂ n₂ (merge le (cons r₁ a₁ n₁ t₁) t₂)
        else
          match combine le a₁ a₂ n₁ n₂ with
          | (a, n) =>
            let r := r₁ + 1;
            if rankGT t₁ r then if rankGT t₂ r then cons r a n (merge le t₁ t₂) else merge le (cons r a n t₁) t₂
            else if rankGT t₂ r then merge le t₁ (cons r a n t₂) else cons r a n (merge le t₁ t₂)) =
    realSize (cons r₁ a₁ n₁ t₁) + realSize (cons r₂ a₂ n₂ t₂)

tactic: have IH₂ r a n := realSize_merge le (cons r a n t₁) t₂
state_before: case h_3
α : Type u_1
le : α → α → Bool
x✝¹ x✝ : Heap α
r₁ : Nat
a₁ : α
n₁ : HeapNode α
t₁ : Heap α
r₂ : Nat
a₂ : α
n₂ : HeapNode α
t₂ : Heap α
IH₁ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le t₁ (cons r a n t₂)) = realSize t₁ + realSize (cons r a n t₂)
⊢ realSize
      (if r₁ < r₂ then cons r₁ a₁ n₁ (merge le t₁ (cons r₂ a₂ n₂ t₂))
      else
        if r₂ < r₁ then cons r₂ a₂ n₂ (merge le (cons r₁ a₁ n₁ t₁) t₂)
        else
          match combine le a₁ a₂ n₁ n₂ with
          | (a, n) =>
            let r := r₁ + 1;
            if rankGT t₁ r then if rankGT t₂ r then cons r a n (merge le t₁ t₂) else merge le (cons r a n t₁) t₂
            else if rankGT t₂ r then merge le t₁ (cons r a n t₂) else cons r a n (merge le t₁ t₂)) =
    realSize (cons r₁ a₁ n₁ t₁) + realSize (cons r₂ a₂ n₂ t₂)

tactic: have IH₃ := realSize_merge le t₁ t₂
state_before: case h_3
α : Type u_1
le : α → α → Bool
x✝¹ x✝ : Heap α
r₁ : Nat
a₁ : α
n₁ : HeapNode α
t₁ : Heap α
r₂ : Nat
a₂ : α
n₂ : HeapNode α
t₂ : Heap α
IH₁ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le t₁ (cons r a n t₂)) = realSize t₁ + realSize (cons r a n t₂)
IH₂ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le (cons r a n t₁) t₂) = realSize (cons r a n t₁) + realSize t₂
⊢ realSize
      (if r₁ < r₂ then cons r₁ a₁ n₁ (merge le t₁ (cons r₂ a₂ n₂ t₂))
      else
        if r₂ < r₁ then cons r₂ a₂ n₂ (merge le (cons r₁ a₁ n₁ t₁) t₂)
        else
          match combine le a₁ a₂ n₁ n₂ with
          | (a, n) =>
            let r := r₁ + 1;
            if rankGT t₁ r then if rankGT t₂ r then cons r a n (merge le t₁ t₂) else merge le (cons r a n t₁) t₂
            else if rankGT t₂ r then merge le t₁ (cons r a n t₂) else cons r a n (merge le t₁ t₂)) =
    realSize (cons r₁ a₁ n₁ t₁) + realSize (cons r₂ a₂ n₂ t₂)

tactic: split
state_before: case h_3
α : Type u_1
le : α → α → Bool
x✝¹ x✝ : Heap α
r₁ : Nat
a₁ : α
n₁ : HeapNode α
t₁ : Heap α
r₂ : Nat
a₂ : α
n₂ : HeapNode α
t₂ : Heap α
IH₁ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le t₁ (cons r a n t₂)) = realSize t₁ + realSize (cons r a n t₂)
IH₂ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le (cons r a n t₁) t₂) = realSize (cons r a n t₁) + realSize t₂
IH₃ : realSize (merge le t₁ t₂) = realSize t₁ + realSize t₂
⊢ realSize
      (if r₁ < r₂ then cons r₁ a₁ n₁ (merge le t₁ (cons r₂ a₂ n₂ t₂))
      else
        if r₂ < r₁ then cons r₂ a₂ n₂ (merge le (cons r₁ a₁ n₁ t₁) t₂)
        else
          match combine le a₁ a₂ n₁ n₂ with
          | (a, n) =>
            let r := r₁ + 1;
            if rankGT t₁ r then if rankGT t₂ r then cons r a n (merge le t₁ t₂) else merge le (cons r a n t₁) t₂
            else if rankGT t₂ r then merge le t₁ (cons r a n t₂) else cons r a n (merge le t₁ t₂)) =
    realSize (cons r₁ a₁ n₁ t₁) + realSize (cons r₂ a₂ n₂ t₂)

tactic: { simp [IH₁, Nat.add_assoc] }
state_before: case h_3.inl
α : Type u_1
le : α → α → Bool
x✝¹ x✝ : Heap α
r₁ : Nat
a₁ : α
n₁ : HeapNode α
t₁ : Heap α
r₂ : Nat
a₂ : α
n₂ : HeapNode α
t₂ : Heap α
IH₁ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le t₁ (cons r a n t₂)) = realSize t₁ + realSize (cons r a n t₂)
IH₂ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le (cons r a n t₁) t₂) = realSize (cons r a n t₁) + realSize t₂
IH₃ : realSize (merge le t₁ t₂) = realSize t₁ + realSize t₂
h✝ : r₁ < r₂
⊢ realSize (cons r₁ a₁ n₁ (merge le t₁ (cons r₂ a₂ n₂ t₂))) = realSize (cons r₁ a₁ n₁ t₁) + realSize (cons r₂ a₂ n₂ t₂)

case h_3.inr
α : Type u_1
le : α → α → Bool
x✝¹ x✝ : Heap α
r₁ : Nat
a₁ : α
n₁ : HeapNode α
t₁ : Heap α
r₂ : Nat
a₂ : α
n₂ : HeapNode α
t₂ : Heap α
IH₁ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le t₁ (cons r a n t₂)) = realSize t₁ + realSize (cons r a n t₂)
IH₂ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le (cons r a n t₁) t₂) = realSize (cons r a n t₁) + realSize t₂
IH₃ : realSize (merge le t₁ t₂) = realSize t₁ + realSize t₂
h✝ : ¬r₁ < r₂
⊢ realSize
      (if r₂ < r₁ then cons r₂ a₂ n₂ (merge le (cons r₁ a₁ n₁ t₁) t₂)
      else
        match combine le a₁ a₂ n₁ n₂ with
        | (a, n) =>
          let r := r₁ + 1;
          if rankGT t₁ r then if rankGT t₂ r then cons r a n (merge le t₁ t₂) else merge le (cons r a n t₁) t₂
          else if rankGT t₂ r then merge le t₁ (cons r a n t₂) else cons r a n (merge le t₁ t₂)) =
    realSize (cons r₁ a₁ n₁ t₁) + realSize (cons r₂ a₂ n₂ t₂)

tactic: split
state_before: case h_3.inr
α : Type u_1
le : α → α → Bool
x✝¹ x✝ : Heap α
r₁ : Nat
a₁ : α
n₁ : HeapNode α
t₁ : Heap α
r₂ : Nat
a₂ : α
n₂ : HeapNode α
t₂ : Heap α
IH₁ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le t₁ (cons r a n t₂)) = realSize t₁ + realSize (cons r a n t₂)
IH₂ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le (cons r a n t₁) t₂) = realSize (cons r a n t₁) + realSize t₂
IH₃ : realSize (merge le t₁ t₂) = realSize t₁ + realSize t₂
h✝ : ¬r₁ < r₂
⊢ realSize
      (if r₂ < r₁ then cons r₂ a₂ n₂ (merge le (cons r₁ a₁ n₁ t₁) t₂)
      else
        match combine le a₁ a₂ n₁ n₂ with
        | (a, n) =>
          let r := r₁ + 1;
          if rankGT t₁ r then if rankGT t₂ r then cons r a n (merge le t₁ t₂) else merge le (cons r a n t₁) t₂
          else if rankGT t₂ r then merge le t₁ (cons r a n t₂) else cons r a n (merge le t₁ t₂)) =
    realSize (cons r₁ a₁ n₁ t₁) + realSize (cons r₂ a₂ n₂ t₂)

tactic: { simp [IH₂, Nat.add_assoc, Nat.add_left_comm] }
state_before: case h_3.inr.inl
α : Type u_1
le : α → α → Bool
x✝¹ x✝ : Heap α
r₁ : Nat
a₁ : α
n₁ : HeapNode α
t₁ : Heap α
r₂ : Nat
a₂ : α
n₂ : HeapNode α
t₂ : Heap α
IH₁ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le t₁ (cons r a n t₂)) = realSize t₁ + realSize (cons r a n t₂)
IH₂ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le (cons r a n t₁) t₂) = realSize (cons r a n t₁) + realSize t₂
IH₃ : realSize (merge le t₁ t₂) = realSize t₁ + realSize t₂
h✝¹ : ¬r₁ < r₂
h✝ : r₂ < r₁
⊢ realSize (cons r₂ a₂ n₂ (merge le (cons r₁ a₁ n₁ t₁) t₂)) = realSize (cons r₁ a₁ n₁ t₁) + realSize (cons r₂ a₂ n₂ t₂)

case h_3.inr.inr
α : Type u_1
le : α → α → Bool
x✝¹ x✝ : Heap α
r₁ : Nat
a₁ : α
n₁ : HeapNode α
t₁ : Heap α
r₂ : Nat
a₂ : α
n₂ : HeapNode α
t₂ : Heap α
IH₁ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le t₁ (cons r a n t₂)) = realSize t₁ + realSize (cons r a n t₂)
IH₂ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le (cons r a n t₁) t₂) = realSize (cons r a n t₁) + realSize t₂
IH₃ : realSize (merge le t₁ t₂) = realSize t₁ + realSize t₂
h✝¹ : ¬r₁ < r₂
h✝ : ¬r₂ < r₁
⊢ realSize
      (match combine le a₁ a₂ n₁ n₂ with
      | (a, n) =>
        let r := r₁ + 1;
        if rankGT t₁ r then if rankGT t₂ r then cons r a n (merge le t₁ t₂) else merge le (cons r a n t₁) t₂
        else if rankGT t₂ r then merge le t₁ (cons r a n t₂) else cons r a n (merge le t₁ t₂)) =
    realSize (cons r₁ a₁ n₁ t₁) + realSize (cons r₂ a₂ n₂ t₂)

tactic: split
state_before: case h_3.inr.inr
α : Type u_1
le : α → α → Bool
x✝¹ x✝ : Heap α
r₁ : Nat
a₁ : α
n₁ : HeapNode α
t₁ : Heap α
r₂ : Nat
a₂ : α
n₂ : HeapNode α
t₂ : Heap α
IH₁ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le t₁ (cons r a n t₂)) = realSize t₁ + realSize (cons r a n t₂)
IH₂ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le (cons r a n t₁) t₂) = realSize (cons r a n t₁) + realSize t₂
IH₃ : realSize (merge le t₁ t₂) = realSize t₁ + realSize t₂
h✝¹ : ¬r₁ < r₂
h✝ : ¬r₂ < r₁
⊢ realSize
      (match combine le a₁ a₂ n₁ n₂ with
      | (a, n) =>
        let r := r₁ + 1;
        if rankGT t₁ r then if rankGT t₂ r then cons r a n (merge le t₁ t₂) else merge le (cons r a n t₁) t₂
        else if rankGT t₂ r then merge le t₁ (cons r a n t₂) else cons r a n (merge le t₁ t₂)) =
    realSize (cons r₁ a₁ n₁ t₁) + realSize (cons r₂ a₂ n₂ t₂)

tactic: simp only
state_before: case h_3.inr.inr
α : Type u_1
le : α → α → Bool
x✝² x✝¹ : Heap α
r₁ : Nat
a₁ : α
n₁ : HeapNode α
t₁ : Heap α
r₂ : Nat
a₂ : α
n₂ : HeapNode α
t₂ : Heap α
IH₁ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le t₁ (cons r a n t₂)) = realSize t₁ + realSize (cons r a n t₂)
IH₂ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le (cons r a n t₁) t₂) = realSize (cons r a n t₁) + realSize t₂
IH₃ : realSize (merge le t₁ t₂) = realSize t₁ + realSize t₂
h✝¹ : ¬r₁ < r₂
h✝ : ¬r₂ < r₁
x✝ : α × HeapNode α
a✝ : α
n✝ : HeapNode α
heq✝ : combine le a₁ a₂ n₁ n₂ = (a✝, n✝)
⊢ realSize
      (let r := r₁ + 1;
      if rankGT t₁ r then if rankGT t₂ r then cons r a✝ n✝ (merge le t₁ t₂) else merge le (cons r a✝ n✝ t₁) t₂
      else if rankGT t₂ r then merge le t₁ (cons r a✝ n✝ t₂) else cons r a✝ n✝ (merge le t₁ t₂)) =
    realSize (cons r₁ a₁ n₁ t₁) + realSize (cons r₂ a₂ n₂ t₂)

tactic: rename_i a n eq
state_before: case h_3.inr.inr
α : Type u_1
le : α → α → Bool
x✝² x✝¹ : Heap α
r₁ : Nat
a₁ : α
n₁ : HeapNode α
t₁ : Heap α
r₂ : Nat
a₂ : α
n₂ : HeapNode α
t₂ : Heap α
IH₁ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le t₁ (cons r a n t₂)) = realSize t₁ + realSize (cons r a n t₂)
IH₂ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le (cons r a n t₁) t₂) = realSize (cons r a n t₁) + realSize t₂
IH₃ : realSize (merge le t₁ t₂) = realSize t₁ + realSize t₂
h✝¹ : ¬r₁ < r₂
h✝ : ¬r₂ < r₁
x✝ : α × HeapNode α
a✝ : α
n✝ : HeapNode α
heq✝ : combine le a₁ a₂ n₁ n₂ = (a✝, n✝)
⊢ realSize
      (if rankGT t₁ (r₁ + 1) then
        if rankGT t₂ (r₁ + 1) then cons (r₁ + 1) a✝ n✝ (merge le t₁ t₂) else merge le (cons (r₁ + 1) a✝ n✝ t₁) t₂
      else if rankGT t₂ (r₁ + 1) then merge le t₁ (cons (r₁ + 1) a✝ n✝ t₂) else cons (r₁ + 1) a✝ n✝ (merge le t₁ t₂)) =
    realSize (cons r₁ a₁ n₁ t₁) + realSize (cons r₂ a₂ n₂ t₂)

tactic: have : n.realSize = n₁.realSize + 1 + n₂.realSize := by
  rw [combine] at eq; split at eq <;> cases eq <;>
    simp [Nat.add_assoc, Nat.add_left_comm, Nat.add_comm]
state_before: case h_3.inr.inr
α : Type u_1
le : α → α → Bool
x✝² x✝¹ : Heap α
r₁ : Nat
a₁ : α
n₁ : HeapNode α
t₁ : Heap α
r₂ : Nat
a₂ : α
n₂ : HeapNode α
t₂ : Heap α
IH₁ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le t₁ (cons r a n t₂)) = realSize t₁ + realSize (cons r a n t₂)
IH₂ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le (cons r a n t₁) t₂) = realSize (cons r a n t₁) + realSize t₂
IH₃ : realSize (merge le t₁ t₂) = realSize t₁ + realSize t₂
h✝¹ : ¬r₁ < r₂
h✝ : ¬r₂ < r₁
x✝ : α × HeapNode α
a : α
n : HeapNode α
eq : combine le a₁ a₂ n₁ n₂ = (a, n)
⊢ realSize
      (if rankGT t₁ (r₁ + 1) then
        if rankGT t₂ (r₁ + 1) then cons (r₁ + 1) a n (merge le t₁ t₂) else merge le (cons (r₁ + 1) a n t₁) t₂
      else if rankGT t₂ (r₁ + 1) then merge le t₁ (cons (r₁ + 1) a n t₂) else cons (r₁ + 1) a n (merge le t₁ t₂)) =
    realSize (cons r₁ a₁ n₁ t₁) + realSize (cons r₂ a₂ n₂ t₂)

tactic: split <;> split <;> simp [IH₁, IH₂, IH₃, this, Nat.add_assoc, Nat.add_left_comm]
state_before: case h_3.inr.inr
α : Type u_1
le : α → α → Bool
x✝² x✝¹ : Heap α
r₁ : Nat
a₁ : α
n₁ : HeapNode α
t₁ : Heap α
r₂ : Nat
a₂ : α
n₂ : HeapNode α
t₂ : Heap α
IH₁ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le t₁ (cons r a n t₂)) = realSize t₁ + realSize (cons r a n t₂)
IH₂ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le (cons r a n t₁) t₂) = realSize (cons r a n t₁) + realSize t₂
IH₃ : realSize (merge le t₁ t₂) = realSize t₁ + realSize t₂
h✝¹ : ¬r₁ < r₂
h✝ : ¬r₂ < r₁
x✝ : α × HeapNode α
a : α
n : HeapNode α
eq : combine le a₁ a₂ n₁ n₂ = (a, n)
this : HeapNode.realSize n = HeapNode.realSize n₁ + 1 + HeapNode.realSize n₂
⊢ realSize
      (if rankGT t₁ (r₁ + 1) then
        if rankGT t₂ (r₁ + 1) then cons (r₁ + 1) a n (merge le t₁ t₂) else merge le (cons (r₁ + 1) a n t₁) t₂
      else if rankGT t₂ (r₁ + 1) then merge le t₁ (cons (r₁ + 1) a n t₂) else cons (r₁ + 1) a n (merge le t₁ t₂)) =
    realSize (cons r₁ a₁ n₁ t₁) + realSize (cons r₂ a₂ n₂ t₂)

tactic: rw [combine] at eq
state_before: α : Type u_1
le : α → α → Bool
x✝² x✝¹ : Heap α
r₁ : Nat
a₁ : α
n₁ : HeapNode α
t₁ : Heap α
r₂ : Nat
a₂ : α
n₂ : HeapNode α
t₂ : Heap α
IH₁ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le t₁ (cons r a n t₂)) = realSize t₁ + realSize (cons r a n t₂)
IH₂ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le (cons r a n t₁) t₂) = realSize (cons r a n t₁) + realSize t₂
IH₃ : realSize (merge le t₁ t₂) = realSize t₁ + realSize t₂
h✝¹ : ¬r₁ < r₂
h✝ : ¬r₂ < r₁
x✝ : α × HeapNode α
a : α
n : HeapNode α
eq : combine le a₁ a₂ n₁ n₂ = (a, n)
⊢ HeapNode.realSize n = HeapNode.realSize n₁ + 1 + HeapNode.realSize n₂

tactic: split at eq <;> cases eq <;>
simp [Nat.add_assoc, Nat.add_left_comm, Nat.add_comm]
state_before: α : Type u_1
le : α → α → Bool
x✝² x✝¹ : Heap α
r₁ : Nat
a₁ : α
n₁ : HeapNode α
t₁ : Heap α
r₂ : Nat
a₂ : α
n₂ : HeapNode α
t₂ : Heap α
IH₁ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le t₁ (cons r a n t₂)) = realSize t₁ + realSize (cons r a n t₂)
IH₂ :
  ∀ (r : Nat) (a : α) (n : HeapNode α), realSize (merge le (cons r a n t₁) t₂) = realSize (cons r a n t₁) + realSize t₂
IH₃ : realSize (merge le t₁ t₂) = realSize t₁ + realSize t₂
h✝¹ : ¬r₁ < r₂
h✝ : ¬r₂ < r₁
x✝ : α × HeapNode α
a : α
n : HeapNode α
eq : (if le a₁ a₂ = true then (a₁, HeapNode.node a₂ n₂ n₁) else (a₂, HeapNode.node a₁ n₁ n₂)) = (a, n)
⊢ HeapNode.realSize n = HeapNode.realSize n₁ + 1 + HeapNode.realSize n₂

tactic: simp_wf
state_before: α : Type u_1
le : α → α → Bool
_x✝ : (_ : Heap α) ×' Heap α
a✝¹ :
  ∀ (y : (_ : Heap α) ×' Heap α),
    (invImage (fun a => PSigma.casesOn a fun s₁ snd => length s₁ + length snd) instWellFoundedRelation).1 y _x✝ →
      realSize (merge le y.1 y.2) = realSize y.1 + realSize y.2
s₁ s₂ : Heap α
a✝ :
  ∀ (y : (_ : Heap α) ×' Heap α),
    (invImage (fun a => PSigma.casesOn a fun s₁ snd => length s₁ + length snd) instWellFoundedRelation).1 y
        { fst := s₁, snd := s₂ } →
      realSize (merge le y.1 y.2) = realSize y.1 + realSize y.2
r₁✝ : Nat
a₁✝ : α
n₁✝ : HeapNode α
t₁✝ : Heap α
r₂✝ : Nat
a₂✝ : α
n₂✝ : HeapNode α
t₂✝ : Heap α
h✝¹ : s₁ = cons r₁✝ a₁✝ n₁✝ t₁✝
h✝ : s₂ = cons r₂✝ a₂✝ n₂✝ t₂✝
r : Nat
a : α
n : HeapNode α
⊢ (invImage (fun a => PSigma.casesOn a fun s₁ snd => length s₁ + length snd) instWellFoundedRelation).1
    { fst := t₁✝, snd := cons r a n t₂✝ } { fst := s₁, snd := s₂ }

tactic: simp_arith [*]
state_before: α : Type u_1
le : α → α → Bool
_x✝ : (_ : Heap α) ×' Heap α
a✝¹ :
  ∀ (y : (_ : Heap α) ×' Heap α),
    (invImage (fun a => PSigma.casesOn a fun s₁ snd => length s₁ + length snd) instWellFoundedRelation).1 y _x✝ →
      realSize (merge le y.1 y.2) = realSize y.1 + realSize y.2
s₁ s₂ : Heap α
a✝ :
  ∀ (y : (_ : Heap α) ×' Heap α),
    (invImage (fun a => PSigma.casesOn a fun s₁ snd => length s₁ + length snd) instWellFoundedRelation).1 y
        { fst := s₁, snd := s₂ } →
      realSize (merge le y.1 y.2) = realSize y.1 + realSize y.2
r₁✝ : Nat
a₁✝ : α
n₁✝ : HeapNode α
t₁✝ : Heap α
r₂✝ : Nat
a₂✝ : α
n₂✝ : HeapNode α
t₂✝ : Heap α
h✝¹ : s₁ = cons r₁✝ a₁✝ n₁✝ t₁✝
h✝ : s₂ = cons r₂✝ a₂✝ n₂✝ t₂✝
r : Nat
a : α
n : HeapNode α
⊢ length t₁✝ + (length t₂✝ + 1) < length s₁ + length s₂