Theorem: Batteries.UnionFind.setParentBump_rankD_lt
File: .lake/packages/batteries/Batteries/Data/UnionFind/Basic.lean

tactic: simp [hP, hR, -Array.get_eq_getElem] at *
state_before: arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : parentD arr i ≠ i → rankD arr i < rankD arr (parentD arr i)
hP : parentD arr' i = if ↑x = i then ↑y else parentD arr i
hR :
  ∀ {i : Nat}, rankD arr' i = if ↑y = i ∧ (arr.get x).rank = (arr.get y).rank then (arr.get y).rank + 1 else rankD arr i
⊢ ¬parentD arr' i = i → rankD arr' i < rankD arr' (parentD arr' i)
state_after: arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
⊢ ¬(if ↑x = i then ↑y else parentD arr i) = i →
    (if ↑y = i ∧ (arr.get x).rank = (arr.get y).rank then (arr.get y).rank + 1 else rankD arr i) <
      if (↑y = if ↑x = i then ↑y else parentD arr i) ∧ (arr.get x).rank = (arr.get y).rank then (arr.get y).rank + 1
      else rankD arr (if ↑x = i then ↑y else parentD arr i)

tactic: split <;> rename_i h₁ <;> [simp [← h₁]; skip] <;>
split <;> rename_i h₂ <;> intro h
state_before: arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
⊢ ¬(if ↑x = i then ↑y else parentD arr i) = i →
    (if ↑y = i ∧ (arr.get x).rank = (arr.get y).rank then (arr.get y).rank + 1 else rankD arr i) <
      if (↑y = if ↑x = i then ↑y else parentD arr i) ∧ (arr.get x).rank = (arr.get y).rank then (arr.get y).rank + 1
      else rankD arr (if ↑x = i then ↑y else parentD arr i)
state_after: case isTrue.isTrue
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ↑y = ↑x ∧ arr[↑x].rank = arr[↑y].rank
h : ¬↑y = ↑x
⊢ arr[↑y].rank + 1 < if arr[↑x].rank = arr[↑y].rank then arr[↑y].rank + 1 else rankD arr ↑y

case isTrue.isFalse
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ arr[↑x].rank = arr[↑y].rank)
h : ¬↑y = ↑x
⊢ rankD arr ↑x < if arr[↑x].rank = arr[↑y].rank then arr[↑y].rank + 1 else rankD arr ↑y

case isFalse.isTrue
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ↑y = i ∧ (arr.get x).rank = (arr.get y).rank
h : ¬parentD arr i = i
⊢ (arr.get y).rank + 1 <
    if ↑y = parentD arr i ∧ (arr.get x).rank = (arr.get y).rank then (arr.get y).rank + 1 else rankD arr (parentD arr i)

case isFalse.isFalse
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (arr.get x).rank = (arr.get y).rank)
h : ¬parentD arr i = i
⊢ rankD arr i <
    if ↑y = parentD arr i ∧ (arr.get x).rank = (arr.get y).rank then (arr.get y).rank + 1 else rankD arr (parentD arr i)

tactic: simp [h₂] at h
state_before: case isTrue.isTrue
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ↑y = ↑x ∧ arr[↑x].rank = arr[↑y].rank
h : ¬↑y = ↑x
⊢ arr[↑y].rank + 1 < if arr[↑x].rank = arr[↑y].rank then arr[↑y].rank + 1 else rankD arr ↑y
state_after: no goals

tactic: simp [rankD_eq]
state_before: case isTrue.isFalse
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ arr[↑x].rank = arr[↑y].rank)
h : ¬↑y = ↑x
⊢ rankD arr ↑x < if arr[↑x].rank = arr[↑y].rank then arr[↑y].rank + 1 else rankD arr ↑y
state_after: case isTrue.isFalse
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ arr[↑x].rank = arr[↑y].rank)
h : ¬↑y = ↑x
⊢ arr[↑x].rank < if arr[↑x].rank = arr[↑y].rank then arr[↑y].rank + 1 else arr[↑y].rank

tactic: split <;> rename_i h₃
state_before: case isTrue.isFalse
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ arr[↑x].rank = arr[↑y].rank)
h : ¬↑y = ↑x
⊢ arr[↑x].rank < if arr[↑x].rank = arr[↑y].rank then arr[↑y].rank + 1 else arr[↑y].rank
state_after: case isTrue.isFalse.isTrue
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ arr[↑x].rank = arr[↑y].rank)
h : ¬↑y = ↑x
h₃ : arr[↑x].rank = arr[↑y].rank
⊢ arr[↑x].rank < arr[↑y].rank + 1

case isTrue.isFalse.isFalse
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ arr[↑x].rank = arr[↑y].rank)
h : ¬↑y = ↑x
h₃ : ¬arr[↑x].rank = arr[↑y].rank
⊢ arr[↑x].rank < arr[↑y].rank

tactic: rw [← h₃]
state_before: case isTrue.isFalse.isTrue
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ arr[↑x].rank = arr[↑y].rank)
h : ¬↑y = ↑x
h₃ : arr[↑x].rank = arr[↑y].rank
⊢ arr[↑x].rank < arr[↑y].rank + 1
state_after: case isTrue.isFalse.isTrue
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ arr[↑x].rank = arr[↑y].rank)
h : ¬↑y = ↑x
h₃ : arr[↑x].rank = arr[↑y].rank
⊢ arr[↑x].rank < arr[↑x].rank + 1

tactic: apply Nat.lt_succ_self
state_before: case isTrue.isFalse.isTrue
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ arr[↑x].rank = arr[↑y].rank)
h : ¬↑y = ↑x
h₃ : arr[↑x].rank = arr[↑y].rank
⊢ arr[↑x].rank < arr[↑x].rank + 1
state_after: no goals

tactic: exact Nat.lt_of_le_of_ne H h₃
state_before: case isTrue.isFalse.isFalse
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ↑x = i
h₂ : ¬(↑y = ↑x ∧ arr[↑x].rank = arr[↑y].rank)
h : ¬↑y = ↑x
h₃ : ¬arr[↑x].rank = arr[↑y].rank
⊢ arr[↑x].rank < arr[↑y].rank
state_after: no goals

tactic: cases h₂.1
state_before: case isFalse.isTrue
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ↑y = i ∧ (arr.get x).rank = (arr.get y).rank
h : ¬parentD arr i = i
⊢ (arr.get y).rank + 1 <
    if ↑y = parentD arr i ∧ (arr.get x).rank = (arr.get y).rank then (arr.get y).rank + 1 else rankD arr (parentD arr i)
state_after: case isFalse.isTrue.refl
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
hP hR : True
rankD_lt : ¬parentD arr ↑y = ↑y → rankD arr ↑y < rankD arr (parentD arr ↑y)
h₁ : ¬↑x = ↑y
h₂ : ↑y = ↑y ∧ (arr.get x).rank = (arr.get y).rank
h : ¬parentD arr ↑y = ↑y
⊢ (arr.get y).rank + 1 <
    if ↑y = parentD arr ↑y ∧ (arr.get x).rank = (arr.get y).rank then (arr.get y).rank + 1
    else rankD arr (parentD arr ↑y)

tactic: simp only [h₂.2, false_or, Nat.lt_irrefl] at hroot
state_before: case isFalse.isTrue.refl
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
hP hR : True
rankD_lt : ¬parentD arr ↑y = ↑y → rankD arr ↑y < rankD arr (parentD arr ↑y)
h₁ : ¬↑x = ↑y
h₂ : ↑y = ↑y ∧ (arr.get x).rank = (arr.get y).rank
h : ¬parentD arr ↑y = ↑y
⊢ (arr.get y).rank + 1 <
    if ↑y = parentD arr ↑y ∧ (arr.get x).rank = (arr.get y).rank then (arr.get y).rank + 1
    else rankD arr (parentD arr ↑y)
state_after: case isFalse.isTrue.refl
arr' arr : Array UFNode
x y : Fin arr.size
H : (arr.get x).rank ≤ (arr.get y).rank
hP hR : True
rankD_lt : ¬parentD arr ↑y = ↑y → rankD arr ↑y < rankD arr (parentD arr ↑y)
h₁ : ¬↑x = ↑y
h₂ : ↑y = ↑y ∧ (arr.get x).rank = (arr.get y).rank
h : ¬parentD arr ↑y = ↑y
hroot : (arr.get y).parent = ↑y
⊢ (arr.get y).rank + 1 <
    if ↑y = parentD arr ↑y ∧ (arr.get x).rank = (arr.get y).rank then (arr.get y).rank + 1
    else rankD arr (parentD arr ↑y)

tactic: simp only [hroot, parentD_eq, not_true_eq_false] at h
state_before: case isFalse.isTrue.refl
arr' arr : Array UFNode
x y : Fin arr.size
H : (arr.get x).rank ≤ (arr.get y).rank
hP hR : True
rankD_lt : ¬parentD arr ↑y = ↑y → rankD arr ↑y < rankD arr (parentD arr ↑y)
h₁ : ¬↑x = ↑y
h₂ : ↑y = ↑y ∧ (arr.get x).rank = (arr.get y).rank
h : ¬parentD arr ↑y = ↑y
hroot : (arr.get y).parent = ↑y
⊢ (arr.get y).rank + 1 <
    if ↑y = parentD arr ↑y ∧ (arr.get x).rank = (arr.get y).rank then (arr.get y).rank + 1
    else rankD arr (parentD arr ↑y)
state_after: no goals

tactic: have := rankD_lt h
state_before: case isFalse.isFalse
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (arr.get x).rank = (arr.get y).rank)
h : ¬parentD arr i = i
⊢ rankD arr i <
    if ↑y = parentD arr i ∧ (arr.get x).rank = (arr.get y).rank then (arr.get y).rank + 1 else rankD arr (parentD arr i)
state_after: case isFalse.isFalse
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (arr.get x).rank = (arr.get y).rank)
h : ¬parentD arr i = i
this : rankD arr i < rankD arr (parentD arr i)
⊢ rankD arr i <
    if ↑y = parentD arr i ∧ (arr.get x).rank = (arr.get y).rank then (arr.get y).rank + 1 else rankD arr (parentD arr i)

tactic: split <;> rename_i h₃
state_before: case isFalse.isFalse
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (arr.get x).rank = (arr.get y).rank)
h : ¬parentD arr i = i
this : rankD arr i < rankD arr (parentD arr i)
⊢ rankD arr i <
    if ↑y = parentD arr i ∧ (arr.get x).rank = (arr.get y).rank then (arr.get y).rank + 1 else rankD arr (parentD arr i)
state_after: case isFalse.isFalse.isTrue
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (arr.get x).rank = (arr.get y).rank)
h : ¬parentD arr i = i
this : rankD arr i < rankD arr (parentD arr i)
h₃ : ↑y = parentD arr i ∧ (arr.get x).rank = (arr.get y).rank
⊢ rankD arr i < (arr.get y).rank + 1

case isFalse.isFalse.isFalse
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (arr.get x).rank = (arr.get y).rank)
h : ¬parentD arr i = i
this : rankD arr i < rankD arr (parentD arr i)
h₃ : ¬(↑y = parentD arr i ∧ (arr.get x).rank = (arr.get y).rank)
⊢ rankD arr i < rankD arr (parentD arr i)

tactic: rw [← rankD_eq, h₃.1]
state_before: case isFalse.isFalse.isTrue
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (arr.get x).rank = (arr.get y).rank)
h : ¬parentD arr i = i
this : rankD arr i < rankD arr (parentD arr i)
h₃ : ↑y = parentD arr i ∧ (arr.get x).rank = (arr.get y).rank
⊢ rankD arr i < (arr.get y).rank + 1
state_after: case isFalse.isFalse.isTrue
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (arr.get x).rank = (arr.get y).rank)
h : ¬parentD arr i = i
this : rankD arr i < rankD arr (parentD arr i)
h₃ : ↑y = parentD arr i ∧ (arr.get x).rank = (arr.get y).rank
⊢ rankD arr i < rankD arr (parentD arr i) + 1

tactic: exact Nat.lt_succ_of_lt this
state_before: case isFalse.isFalse.isTrue
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (arr.get x).rank = (arr.get y).rank)
h : ¬parentD arr i = i
this : rankD arr i < rankD arr (parentD arr i)
h₃ : ↑y = parentD arr i ∧ (arr.get x).rank = (arr.get y).rank
⊢ rankD arr i < rankD arr (parentD arr i) + 1
state_after: no goals

tactic: exact this
state_before: case isFalse.isFalse.isFalse
arr' arr : Array UFNode
x y : Fin arr.size
hroot : (arr.get x).rank < (arr.get y).rank ∨ (arr.get y).parent = ↑y
H : (arr.get x).rank ≤ (arr.get y).rank
i : Nat
rankD_lt : ¬parentD arr i = i → rankD arr i < rankD arr (parentD arr i)
hP hR : True
h₁ : ¬↑x = i
h₂ : ¬(↑y = i ∧ (arr.get x).rank = (arr.get y).rank)
h : ¬parentD arr i = i
this : rankD arr i < rankD arr (parentD arr i)
h₃ : ¬(↑y = parentD arr i ∧ (arr.get x).rank = (arr.get y).rank)
⊢ rankD arr i < rankD arr (parentD arr i)
state_after: no goals