Theorem: Algdata.BinaryHeap.heapifyDown.OpSpec.get_as_eq_of_lt_start
Proof state before:
case hik.refl
α : Type u
lt : α → α → Bool
x✝ : Subarray α
i✝ : Nat
y✝ x : Subarray α
i : Nat
y : Subarray α
hi : i < Subarray.size x
hl : 2 * i + 1 < Subarray.size x
hr : 2 * i + 2 < Subarray.size x
hx' : lt x[2 * i + 2] x[2 * i + 1] = true
hx : lt x[i] x[2 * i + 1] = true
a✝ : heapifyDown.OpSpec lt (Subarray.swap x { val := i, isLt := hi } { val := 2 * i + 1, isLt := hl }) (2 * i + 1) y
IH :
  ∀ {hk : ↑(Subarray.castIndex x { val := i, isLt := hi }) < Array.size y.as},
    ↑(Subarray.castIndex x { val := i, isLt := hi }) <
        (Subarray.swap x { val := i, isLt := hi } { val := 2 * i + 1, isLt := hl }).start →
      y.as[↑(Subarray.castIndex x { val := i, isLt := hi })] =
        (Subarray.swap x { val := i, isLt := hi }
              { val := 2 * i + 1, isLt := hl }).as[↑(Subarray.castIndex x { val := i, isLt := hi })]
hk : ↑(Subarray.castIndex x { val := i, isLt := hi }) < Array.size y.as
hlt : ↑(Subarray.castIndex x { val := i, isLt := hi }) < x.start
⊢ False

case hjk.refl
α : Type u
lt : α → α → Bool
x✝ : Subarray α
i✝ : Nat
y✝ x : Subarray α
i : Nat
y : Subarray α
hi : i < Subarray.size x
hl : 2 * i + 1 < Subarray.size x
hr : 2 * i + 2 < Subarray.size x
hx' : lt x[2 * i + 2] x[2 * i + 1] = true
hx : lt x[i] x[2 * i + 1] = true
a✝ : heapifyDown.OpSpec lt (Subarray.swap x { val := i, isLt := hi } { val := 2 * i + 1, isLt := hl }) (2 * i + 1) y
IH :
  ∀ {hk : ↑(Subarray.castIndex x { val := 2 * i + 1, isLt := hl }) < Array.size y.as},
    ↑(Subarray.castIndex x { val := 2 * i + 1, isLt := hl }) <
        (Subarray.swap x { val := i, isLt := hi } { val := 2 * i + 1, isLt := hl }).start →
      y.as[↑(Subarray.castIndex x { val := 2 * i + 1, isLt := hl })] =
        (Subarray.swap x { val := i, isLt := hi }
              { val := 2 * i + 1, isLt := hl }).as[↑(Subarray.castIndex x { val := 2 * i + 1, isLt := hl })]
hk : ↑(Subarray.castIndex x { val := 2 * i + 1, isLt := hl }) < Array.size y.as
hlt : ↑(Subarray.castIndex x { val := 2 * i + 1, isLt := hl }) < x.start
⊢ False
Tactic:
. exact Nat.not_le_of_lt hlt <| x.start.le_add_right i
Proof state after:
case hjk.refl
α : Type u
lt : α → α → Bool
x✝ : Subarray α
i✝ : Nat
y✝ x : Subarray α
i : Nat
y : Subarray α
hi : i < Subarray.size x
hl : 2 * i + 1 < Subarray.size x
hr : 2 * i + 2 < Subarray.size x
hx' : lt x[2 * i + 2] x[2 * i + 1] = true
hx : lt x[i] x[2 * i + 1] = true
a✝ : heapifyDown.OpSpec lt (Subarray.swap x { val := i, isLt := hi } { val := 2 * i + 1, isLt := hl }) (2 * i + 1) y
IH :
  ∀ {hk : ↑(Subarray.castIndex x { val := 2 * i + 1, isLt := hl }) < Array.size y.as},
    ↑(Subarray.castIndex x { val := 2 * i + 1, isLt := hl }) <
        (Subarray.swap x { val := i, isLt := hi } { val := 2 * i + 1, isLt := hl }).start →
      y.as[↑(Subarray.castIndex x { val := 2 * i + 1, isLt := hl })] =
        (Subarray.swap x { val := i, isLt := hi }
              { val := 2 * i + 1, isLt := hl }).as[↑(Subarray.castIndex x { val := 2 * i + 1, isLt := hl })]
hk : ↑(Subarray.castIndex x { val := 2 * i + 1, isLt := hl }) < Array.size y.as
hlt : ↑(Subarray.castIndex x { val := 2 * i + 1, isLt := hl }) < x.start
⊢ False