structure Batteries.UFNode : Type

Union-find node type

• parent : Nat

  Parent of node

• rank : Nat

  Rank of node

def Batteries.UnionFind.parentD (arr : Array UFNode) (i : Nat) : Nat

Parent of a union-find node, defaults to self when the node is a root

def Batteries.UnionFind.rankD (arr : Array UFNode) (i : Nat) : Nat

Rank of a union-find node, defaults to 0 when the node is a root

theorem Batteries.UnionFind.parentD_eq {arr : Array UFNode} {i : Nat} (h : i < arr.size) : parentD arr i = arr[i].parent

theorem Batteries.UnionFind.rankD_eq {arr : Array UFNode} {i : Nat} (h : i < arr.size) : rankD arr i = arr[i].rank

theorem Batteries.UnionFind.parentD_of_not_lt {i : Nat} {arr : Array UFNode} : ¬i < arr.size → parentD arr i = i

theorem Batteries.UnionFind.lt_of_parentD {arr : Array UFNode} {i : Nat} : parentD arr i ≠ i → i < arr.size

theorem Batteries.UnionFind.parentD_set {arr : Array UFNode} {x : Nat} {v : UFNode} {i : Nat} {h : x < arr.size} : parentD (arr.set x v h) i = if x = i then v.parent else parentD arr i

theorem Batteries.UnionFind.rankD_set {arr : Array UFNode} {x : Nat} {v : UFNode} {i : Nat} {h : x < arr.size} : rankD (arr.set x v h) i = if x = i then v.rank else rankD arr i

structure Batteries.UnionFind : Type

Union-find data structure

The UnionFind structure is an implementation of disjoint-set data structure that uses path compression to make the primary operations run in amortized nearly linear time. The nodes of a UnionFind structure s are natural numbers smaller than s.size. The structure associates with a canonical representative from its equivalence class. The structure can be extended using the push operation and equivalence classes can be updated using the union operation.

The main operations for UnionFind are:

• empty/mkEmpty are used to create a new empty structure.
• size returns the size of the data structure.
• push adds a new node to a structure, unlinked to any other node.
• union links two nodes of the data structure, joining their equivalence classes, and performs path compression.
• find returns the canonical representative of a node and updates the data structure using path compression.
• root returns the canonical representative of a node without altering the data structure.
• checkEquiv checks whether two nodes have the same canonical representative and updates the structure using path compression.

Most use cases should prefer find over root to benefit from the speedup from path-compression.

The main operations use Fin s.size to represent nodes of the union-find structure. Some alternatives are provided:

• unionN, findN, rootN, checkEquivN use Fin n with a proof that n = s.size.
• union!, find!, root!, checkEquiv! use Nat and panic when the indices are out of bounds.
• findD, rootD, checkEquivD use Nat and treat out of bound indices as isolated nodes.

The noncomputable relation UnionFind.Equiv is provided to use the equivalence relation from a UnionFind structure in the context of proofs.

• arr : Array UFNode

  Array of union-find nodes

• parentD_lt {i : Nat} : i < self.arr.size → parentD self.arr i < self.arr.size

  Validity for parent nodes

• rankD_lt {i : Nat} : parentD self.arr i ≠ i → rankD self.arr i < rankD self.arr (parentD self.arr i)

  Validity for rank

@[reducible, inline]

abbrev Batteries.UnionFind.size (self : UnionFind) : Nat

Size of union-find structure.

def Batteries.UnionFind.mkEmpty (c : Nat) : UnionFind

Create an empty union-find structure with specific capacity

def Batteries.UnionFind.empty : UnionFind

Empty union-find structure

instance Batteries.UnionFind.instEmptyCollection : EmptyCollection UnionFind

@[reducible, inline]

abbrev Batteries.UnionFind.parent (self : UnionFind) (i : Nat) : Nat

Parent of union-find node

theorem Batteries.UnionFind.parent'_lt (self : UnionFind) (i : Nat) (h : i < self.arr.size) : self.arr[i].parent < self.size

theorem Batteries.UnionFind.parent_lt (self : UnionFind) (i : Nat) : self.parent i < self.size ↔ i < self.size

@[reducible, inline]

abbrev Batteries.UnionFind.rank (self : UnionFind) (i : Nat) : Nat

Rank of union-find node

theorem Batteries.UnionFind.rank_lt {self : UnionFind} {i : Nat} : self.parent i ≠ i → self.rank i < self.rank (self.parent i)

theorem Batteries.UnionFind.rank'_lt (self : UnionFind) (i : Nat) (h : i < self.arr.size) : self.arr[i].parent ≠ i → self.rank i < self.rank self.arr[i].parent

noncomputable def Batteries.UnionFind.rankMax (self : UnionFind) : Nat

Maximum rank of nodes in a union-find structure

theorem Batteries.UnionFind.rank'_lt_rankMax (self : UnionFind) (i : Nat) (h : i < self.arr.size) : self.arr[i].rank < self.rankMax

theorem Batteries.UnionFind.rank'_lt_rankMax.go {l : List UFNode} {x : UFNode} : x ∈ l → x.rank ≤ List.foldr (fun (x : UFNode) => max x.rank) 0 l

theorem Batteries.UnionFind.rankD_lt_rankMax (self : UnionFind) (i : Nat) : rankD self.arr i < self.rankMax

theorem Batteries.UnionFind.lt_rankMax (self : UnionFind) (i : Nat) : self.rank i < self.rankMax

theorem Batteries.UnionFind.push_rankD {i : Nat} (arr : Array UFNode) : rankD (arr.push { parent := arr.size, rank := 0 }) i = rankD arr i

theorem Batteries.UnionFind.push_parentD {i : Nat} (arr : Array UFNode) : parentD (arr.push { parent := arr.size, rank := 0 }) i = parentD arr i

def Batteries.UnionFind.push (self : UnionFind) : UnionFind

Add a new node to a union-find structure, unlinked with any other nodes

@[irreducible]

def Batteries.UnionFind.root (self : UnionFind) (x : Fin self.size) : Fin self.size

Root of a union-find node.

def Batteries.UnionFind.rootN {n : Nat} (self : UnionFind) (x : Fin n) (h : n = self.size) : Fin n

Root of a union-find node.

def Batteries.UnionFind.root! (self : UnionFind) (x : Nat) : Nat

Root of a union-find node. Panics if index is out of bounds.

def Batteries.UnionFind.rootD (self : UnionFind) (x : Nat) : Nat

Root of a union-find node. Returns input if index is out of bounds.

@[irreducible]

theorem Batteries.UnionFind.parent_root (self : UnionFind) (x : Fin self.size) : self.arr[↑(self.root x)].parent = ↑(self.root x)

theorem Batteries.UnionFind.parent_rootD (self : UnionFind) (x : Nat) : self.parent (self.rootD x) = self.rootD x

theorem Batteries.UnionFind.rootD_parent (self : UnionFind) (x : Nat) : self.rootD (self.parent x) = self.rootD x

theorem Batteries.UnionFind.rootD_lt {self : UnionFind} {x : Nat} : self.rootD x < self.size ↔ x < self.size

theorem Batteries.UnionFind.rootD_eq_self {self : UnionFind} {x : Nat} : self.rootD x = x ↔ self.parent x = x

theorem Batteries.UnionFind.rootD_rootD {self : UnionFind} {x : Nat} : self.rootD (self.rootD x) = self.rootD x

@[irreducible]

theorem Batteries.UnionFind.rootD_ext {m1 m2 : UnionFind} (H : ∀ (x : Nat), m1.parent x = m2.parent x) {x : Nat} : m1.rootD x = m2.rootD x

@[irreducible]

theorem Batteries.UnionFind.le_rank_root {self : UnionFind} {x : Nat} : self.rank x ≤ self.rank (self.rootD x)

theorem Batteries.UnionFind.lt_rank_root {self : UnionFind} {x : Nat} : self.rank x < self.rank (self.rootD x) ↔ self.parent x ≠ x

structure Batteries.UnionFind.FindAux (n : Nat) : Type

Auxiliary data structure for find operation

• s : Array UFNode

  Array of nodes

• root : Fin n

  Index of root node

• size_eq : self.s.size = n

  Size requirement

@[irreducible]

def Batteries.UnionFind.findAux (self : UnionFind) (x : Fin self.size) : FindAux self.size

Auxiliary function for find operation

@[irreducible]

theorem Batteries.UnionFind.findAux_root {self : UnionFind} {x : Fin self.size} : (self.findAux x).root = self.root x

theorem Batteries.UnionFind.findAux_s {self : UnionFind} {x : Fin self.size} : (self.findAux x).s = if self.arr[↑x].parent = ↑x then self.arr else (self.findAux ⟨self.arr[↑x].parent, ⋯⟩).s.modify ↑x fun (s : UFNode) => { parent := self.rootD ↑x, rank := s.rank }

@[irreducible]

theorem Batteries.UnionFind.rankD_findAux {i : Nat} {self : UnionFind} {x : Fin self.size} : rankD (self.findAux x).s i = self.rank i

theorem Batteries.UnionFind.parentD_findAux {i : Nat} {self : UnionFind} {x : Fin self.size} : parentD (self.findAux x).s i = if i = ↑x then self.rootD ↑x else parentD (self.findAux ⟨self.arr[↑x].parent, ⋯⟩).s i

@[irreducible]

theorem Batteries.UnionFind.parentD_findAux_rootD {self : UnionFind} {x : Fin self.size} : parentD (self.findAux x).s (self.rootD ↑x) = self.rootD ↑x

@[irreducible]

theorem Batteries.UnionFind.parentD_findAux_lt {i : Nat} {self : UnionFind} {x : Fin self.size} (h : i < self.size) : parentD (self.findAux x).s i < self.size

@[irreducible]

theorem Batteries.UnionFind.parentD_findAux_or (self : UnionFind) (x : Fin self.size) (i : Nat) : parentD (self.findAux x).s i = self.rootD i ∧ self.rootD i = self.rootD ↑x ∨ parentD (self.findAux x).s i = self.parent i

@[irreducible]

theorem Batteries.UnionFind.lt_rankD_findAux {i : Nat} {self : UnionFind} {x : Fin self.size} : parentD (self.findAux x).s i ≠ i → self.rank i < self.rank (parentD (self.findAux x).s i)

def Batteries.UnionFind.find (self : UnionFind) (x : Fin self.size) : (s : UnionFind) × { _root : Fin s.size // s.size = self.size }

Find root of a union-find node, updating the structure using path compression.

def Batteries.UnionFind.findN {n : Nat} (self : UnionFind) (x : Fin n) (h : n = self.size) : UnionFind × Fin n

Find root of a union-find node, updating the structure using path compression.

def Batteries.UnionFind.find! (self : UnionFind) (x : Nat) : UnionFind × Nat

Find root of a union-find node, updating the structure using path compression. Panics if index is out of bounds.

def Batteries.UnionFind.findD (self : UnionFind) (x : Nat) : UnionFind × Nat

Find root of a union-find node, updating the structure using path compression. Returns inputs unchanged when index is out of bounds.

@[simp]

theorem Batteries.UnionFind.find_size (self : UnionFind) (x : Fin self.size) : (self.find x).fst.size = self.size

@[simp]

theorem Batteries.UnionFind.find_root_2 (self : UnionFind) (x : Fin self.size) : ↑(self.find x).snd.val = self.rootD ↑x

@[simp]

theorem Batteries.UnionFind.find_parent_1 (self : UnionFind) (x : Fin self.size) : (self.find x).fst.parent ↑x = self.rootD ↑x

theorem Batteries.UnionFind.find_parent_or (self : UnionFind) (x : Fin self.size) (i : Nat) : (self.find x).fst.parent i = self.rootD i ∧ self.rootD i = self.rootD ↑x ∨ (self.find x).fst.parent i = self.parent i

@[simp, irreducible]

theorem Batteries.UnionFind.find_root_1 (self : UnionFind) (x : Fin self.size) (i : Nat) : (self.find x).fst.rootD i = self.rootD i

def Batteries.UnionFind.linkAux (self : Array UFNode) (x y : Fin self.size) : Array UFNode

Link two union-find nodes

theorem Batteries.UnionFind.setParentBump_rankD_lt {arr' arr : Array UFNode} {x y : Fin arr.size} (hroot : arr[↑x].rank < arr[↑y].rank ∨ arr[↑y].parent = ↑y) (H : arr[↑x].rank ≤ arr[↑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[↑x].rank = arr[↑y].rank then arr[↑y].rank + 1 else rankD arr i) : ¬parentD arr' i = i → rankD arr' i < rankD arr' (parentD arr' i)

theorem Batteries.UnionFind.setParent_rankD_lt {arr : Array UFNode} {x y : Fin arr.size} (h : arr[↑x].rank < arr[↑y].rank) {i : Nat} (rankD_lt : parentD arr i ≠ i → rankD arr i < rankD arr (parentD arr i)) : have arr' := arr.set ↑x { parent := ↑y, rank := arr[x].rank } ⋯; parentD arr' i ≠ i → rankD arr' i < rankD arr' (parentD arr' i)

@[simp]

theorem Batteries.UnionFind.linkAux_size {self : Array UFNode} {x y : Fin self.size} : (linkAux self x y).size = self.size

def Batteries.UnionFind.link (self : UnionFind) (x y : Fin self.size) (yroot : self.parent ↑y = ↑y) : UnionFind

Link a union-find node to a root node.

def Batteries.UnionFind.linkN {n : Nat} (self : UnionFind) (x y : Fin n) (yroot : self.parent ↑y = ↑y) (h : n = self.size) : UnionFind

Link a union-find node to a root node.

def Batteries.UnionFind.link! (self : UnionFind) (x y : Nat) (yroot : self.parent y = y) : UnionFind

Link a union-find node to a root node. Panics if either index is out of bounds.

def Batteries.UnionFind.union (self : UnionFind) (x y : Fin self.size) : UnionFind

Link two union-find nodes, uniting their respective classes.

def Batteries.UnionFind.unionN {n : Nat} (self : UnionFind) (x y : Fin n) (h : n = self.size) : UnionFind

Link two union-find nodes, uniting their respective classes.

def Batteries.UnionFind.union! (self : UnionFind) (x y : Nat) : UnionFind

Link two union-find nodes, uniting their respective classes. Panics if either index is out of bounds.

def Batteries.UnionFind.checkEquiv (self : UnionFind) (x y : Fin self.size) : UnionFind × Bool

Check whether two union-find nodes are equivalent, updating structure using path compression.

def Batteries.UnionFind.checkEquivN {n : Nat} (self : UnionFind) (x y : Fin n) (h : n = self.size) : UnionFind × Bool

Check whether two union-find nodes are equivalent, updating structure using path compression.

def Batteries.UnionFind.checkEquiv! (self : UnionFind) (x y : Nat) : UnionFind × Bool

Check whether two union-find nodes are equivalent, updating structure using path compression. Panics if either index is out of bounds.

def Batteries.UnionFind.checkEquivD (self : UnionFind) (x y : Nat) : UnionFind × Bool

Check whether two union-find nodes are equivalent with path compression, returns x == y if either index is out of bounds

def Batteries.UnionFind.Equiv (self : UnionFind) (a b : Nat) : Prop

Equivalence relation from a UnionFind structure