BFS Link Iteration Rule Overview

• BFS link iteration rule is a traversal mechanism that defines how to expand the current frontier by scanning all outgoing edges while ensuring each vertex is discovered once.
• It encompasses multiple forms such as level-synchronous updates, canonical parent selection for symmetry breaking, and temporal neighbor expansion in evolving graphs.
• The rule underpins efficient graph search algorithms in sequential, parallel, and distributed environments, including matrix-driven and hybrid approaches.

Breadth-first search (BFS) link iteration rule denotes the operational condition that determines how a traversal expands a current frontier, scans adjacency links, and decides when a vertex is first reached and inserted into the next layer. Across the literature, the rule appears in several formally distinct forms: as a level-synchronous frontier recurrence in ordinary graph search, as a canonical parent-selection constraint in BFS-enumerated graphs, as temporal forward-neighbor expansion in evolving graphs, as a nonzero-state transition in matrix-driven traversals, and as an implementation rule governing gray-vertex, bitmap, queue, or distributed-frontier iteration (Wan et al., 17 Jul 2025, Moklev et al., 2018, Chen et al., 2016, Prolubnikov, 2024). For the FOON-specific paper "A comparative study of the performance of different search algorithms on FOON graphs" (Shashwat, 2022), no PDF or source is available in the supplied material, so no FOON-specific BFS procedure, link iteration rule, stopping condition, or comparative technical detail can be extracted faithfully.

1. Static frontier expansion

In the ordinary formulation restated in the semi-external BFS study, BFS starts from a source node $s$, marks $s$ visited, and enqueues all out-neighbors $N^+(s,G)$. It then repeatedly dequeues the first node $u$, and, if $u$ is unmarked, marks $u$ and enqueues all its out-neighbors. The underlying layer-expansion rule is written as

$$\text{frontier}_{\ell+1} = \{\, v \mid \exists u\in \text{frontier}_\ell,\ (u,v)\in E,\ v \notin \text{visited} \,\},$$

with

$N^+(u,G)=\{v \mid (u,v)\in E(G)\}.$

The same source states the standard running time as $O(n+m)$, using a queue $Q$ of size $s$0 (Wan et al., 17 Jul 2025).

The multicore study "Performance-Driven Optimization of Parallel Breadth-First Search" (Bhaskar et al., 1 Mar 2025) presents the same rule in CSR form. For each frontier vertex src, the traversal scans all adjacency entries in the range

$s$1

and visits dst if it has not been reached with a shorter distance. The Xeon Phi top-down study gives the corresponding predecessor-form update: $s$2 These formulations agree on the core link iteration rule: traverse all outgoing adjacency entries of the current frontier and admit a neighbor into the next frontier only if it is not already discovered (Paredes et al., 2016, Bhaskar et al., 1 Mar 2025).

2. Canonical parent selection and BFS-enumerated graphs

In symmetry breaking for SAT/CSP graph search, the BFS link iteration rule is not expressed as a queue operation but as a predicate on vertex numbering and parent assignment. A connected undirected graph $s$3 is BFS-enumerated when there exists a BFS traversal such that, for all $s$4 from $s$5 to $s$6, the $s$7-th vertex in this traversal has label $s$8. The encoding introduces parent variables $s$9 for $N^+(s,G)$0, where $N^+(s,G)$1 denotes the label of the parent of node $N^+(s,G)$2, and constrains them by

$N^+(s,G)$3

together with the canonical parent rule

$N^+(s,G)$4

This is the paper’s central BFS link iteration condition: vertex $N^+(s,G)$5 links to the smallest-numbered earlier vertex adjacent to it (Moklev et al., 2018).

The same study emphasizes that BFS traversal induces layers but does not constrain the order of vertices within a layer. That observation motivates the strengthened predicates $N^+(s,G)$6 and $N^+(s,G)$7. The former fixes the start vertex by requiring

$N^+(s,G)$8

while the latter orders siblings by subtree weight: $N^+(s,G)$9 The paper proves that $u$0, $u$1, and $u$2 are all symmetry-breaking predicates among connected graphs. A common misconception is therefore that a BFS order is intrinsically unique; the paper shows that plain BFS enumeration still leaves symmetries, and that additional root-selection and subtree-ordering constraints are needed to obtain a more canonical numbering (Moklev et al., 2018).

3. Temporal forward neighbors and causal links

For evolving graphs, the BFS link iteration rule is generalized from spatial adjacency to adjacency in space and time. An evolving graph is a time-ordered sequence

$u$3

and a temporal node is a pair

$u$4

The paper allows causal edges

$u$5

which represent waiting or propagation of identity through time. The BFS update is therefore not restricted to same-time neighbors: when a frontier node $u$6 is expanded, the algorithm must follow both spatial links at time $u$7 and causal links to the same node at later active times. The recurrence is given as

$u$8

with already-reached temporal nodes removed (Chen et al., 2016).

The same paper shows that naive unfolding of adjacency matrices miscounts temporal paths. In its example, the naive product yields

$u$9

even though there are actually two valid temporal paths from $u$0 to $u$1. The discrepancy is caused by ignoring causal edges. Adding ones on the diagonal does not repair the issue, because it introduces illegal paths that stay on inactive nodes. The paper resolves this by mapping the evolving graph to an equivalent static directed graph whose vertices are the active temporal nodes and whose edges include both within-time edges and causal edges $u$2. Under that mapping, BFS on the evolving graph is equivalent to ordinary BFS on the corresponding static graph (Chen et al., 2016).

4. Algebraic iteration rules and matrix-driven traversals

A different line of work derives BFS-like traversal rules from iterative methods for solving a linear system built from a graph’s adjacency matrix. In that framework, the graph matrix is modified by replacing zero diagonal entries with a positive value $u$3, the right-hand side is chosen as $u$4, and the initial state is $u$5. A vertex enters the frontier when its state-vector component changes from zero to nonzero: $u$6 This transition rule defines the frontier $u$7. The paper also states the basic BFS-algebraic recurrence

$u$8

and interprets the nonzero components of $u$9 as the vertices reached after iteration $u$0 (Prolubnikov, 2024).

Within this framework, the Jacobi-based traversal rule is

$u$1

and Theorem 1 states that, with $u$2 and $u$3, Jacobi iterations produce the same traversal as combinatorial BFS. By contrast, the Gauss-Seidel rule

$u$4

produces Correct Chain Search (CCS), which is generally neither BFS nor DFS. The paper defines a correct chain as

$u$5

Because values computed earlier in the same sweep can influence later components immediately, CCS may continue along correct chains in a single iteration. The paper formalizes that, for the same starting vertex on a connected graph, CCS completes its work in a number of iterations equal to or less than required for BFS, and for many instances fewer iterations are required. A plausible implication is that the BFS link iteration rule can be viewed not only as a combinatorial queue discipline but also as a particular numerical update policy, with Gauss-Seidel exposing the effect of vertex numbering on propagation (Prolubnikov, 2024).

5. Frontier representations, coloring schemes, and dominance pruning

Several studies preserve BFS layer semantics while replacing the conventional queue by a specialized frontier representation. In the space-efficient 3-color BFS, vertices are colored white, gray, or black. The abstract algorithm performs an exploration round over all gray vertices and colors gray all white neighbors of an eligible vertex $u$6, where, in undirected graphs, eligibility means $u$7 or $u$8 has a black neighbor. A consolidation round then colors $u$9 black if it has no white neighbor. The technical novelty is dynamic iteration over the changing set of gray vertices, not a new graph-theoretic visitation order. The paper proves that BFS can be carried out in $$\text{frontier}_{\ell+1} = \{\, v \mid \exists u\in \text{frontier}_\ell,\ (u,v)\in E,\ v \notin \text{visited} \,\},$$0 time with

$$\text{frontier}_{\ell+1} = \{\, v \mid \exists u\in \text{frontier}_\ell,\ (u,v)\in E,\ v \notin \text{visited} \,\},$$1

bits of working memory (Hagerup, 2018).

The in-place BFS on the word RAM replaces the queue by a 4-color choice dictionary with colors white, light-gray, dark-gray, and black. Light-gray vertices form the current frontier, dark-gray vertices are the next frontier, and after processing a vertex it becomes black. For a frontier vertex $$\text{frontier}_{\ell+1} = \{\, v \mid \exists u\in \text{frontier}_\ell,\ (u,v)\in E,\ v \notin \text{visited} \,\},$$2, the adjacency scan is specified by

$$\text{frontier}_{\ell+1} = \{\, v \mid \exists u\in \text{frontier}_\ell,\ (u,v)\in E,\ v \notin \text{visited} \,\},$$3

and for each

$$\text{frontier}_{\ell+1} = \{\, v \mid \exists u\in \text{frontier}_\ell,\ (u,v)\in E,\ v \notin \text{visited} \,\},$$4

the algorithm checks whether $$\text{frontier}_{\ell+1} = \{\, v \mid \exists u\in \text{frontier}_\ell,\ (u,v)\in E,\ v \notin \text{visited} \,\},$$5; if so, it colors $$\text{frontier}_{\ell+1} = \{\, v \mid \exists u\in \text{frontier}_\ell,\ (u,v)\in E,\ v \notin \text{visited} \,\},$$6 with the next frontier color. The frontier colors alternate by round parity, so if $$\text{frontier}_{\ell+1} = \{\, v \mid \exists u\in \text{frontier}_\ell,\ (u,v)\in E,\ v \notin \text{visited} \,\},$$7 is even the algorithm processes light-gray and colors newly found vertices dark-gray, and if $$\text{frontier}_{\ell+1} = \{\, v \mid \exists u\in \text{frontier}_\ell,\ (u,v)\in E,\ v \notin \text{visited} \,\},$$8 is odd the roles reverse (Kammer et al., 2018).

A more abstract reformulation appears in Efficient Breadth-First Search (EBFS). There the frontier is not a set of vertices but a set of subspaces, and link iteration is embedded in a recursive rule that expands all subspaces of the current frontier and keeps only the undominated ones: $$\text{frontier}_{\ell+1} = \{\, v \mid \exists u\in \text{frontier}_\ell,\ (u,v)\in E,\ v \notin \text{visited} \,\},$$9 The pseudo-Haskell schema $s$18 shows that breadth-wise expansion can be preserved while pruning dominated children before recursion. This suggests that the essential content of a BFS link iteration rule is layerwise expansion plus an admissibility condition; the concrete frontier representation may vary substantially (Nedunuri et al., 2012).

6. Parallel, hybrid, and distributed edge iteration

In ordered parallel BFS by arc elimination, the current frontier is an explicit queue $N^+(u,G)=\{v \mid (u,v)\in E(G)\}.$0, and the next frontier is $N^+(u,G)=\{v \mid (u,v)\in E(G)\}.$1. For each dequeued vertex $N^+(u,G)=\{v \mid (u,v)\in E(G)\}.$2, the algorithm scans still-uneliminated outgoing arcs in fixed adjacency order, using the condition

$N^+(u,G)=\{v \mid (u,v)\in E(G)\}.$3

to test whether a non-eliminated outgoing arc remains. When a new target $N^+(u,G)=\{v \mid (u,v)\in E(G)\}.$4 is discovered, all incoming arcs of $N^+(u,G)=\{v \mid (u,v)\in E(G)\}.$5 are eliminated in parallel, and the algorithm updates

$N^+(u,G)=\{v \mid (u,v)\in E(G)\}.$6

before enqueuing $N^+(u,G)=\{v \mid (u,v)\in E(G)\}.$7 into $N^+(u,G)=\{v \mid (u,v)\in E(G)\}.$8. The elimination invariant ensures that once a vertex is visited it cannot be rediscovered (Träff, 2013).

Hybrid BFS modifies the link iteration domain rather than the basic distance-layer semantics. In top-down mode, the current frontier is expanded by scanning all outgoing neighbors of each frontier vertex. In bottom-up mode, the algorithm iterates over all unvisited vertices, scans each adjacency list, and stops at the first neighbor found in the current frontier: $s$19 One paper uses the simplified switching rule

$N^+(u,G)=\{v \mid (u,v)\in E(G)\}.$9

while another presents architecture-specific threshold functions $O(n+m)$0 and $O(n+m)$1. The same 2025 study also introduces a non-atomic distance update mechanism in which multiple threads may write the same level value concurrently; it explicitly notes that this is technically a C++ data race / undefined behavior, although the concurrent writes are intended to be value-consistent in the level-synchronous setting (Bhaskar et al., 1 Mar 2025, Paredes et al., 2017).

Vectorized implementations retain the same acceptance rule but batch adjacency tests. In top-down Xeon Phi BFS, the bitmap-based discovery condition is

$O(n+m)$2

implemented with gather and scatter over 16 lanes. In vectorized bottom-up BFS, the algorithm loads 16 consecutive vertices, filters visited vertices with a bitmap mask, iterates over adjacency positions in lockstep up to MAX_POS, and falls back to scalar bottom-up processing when necessary. At the distributed scale, ButterFly BFS keeps two queues per compute-node, Q_global[g] and Q_local[g], and applies a level-synchronous traversal rule: $s$20 followed by butterfly synchronization over rounds determined by ButterflyDirection(g,i). The paper characterizes the communication depth as

$O(n+m)$3

with $O(n+m)$4 messages per compute-node and buffer requirement $O(n+m)$5 (Paredes et al., 2016, Paredes et al., 2017, Green, 2021).

7. External, semi-external, and unavailable FOON-specific formulations

External-memory and semi-external studies shift the emphasis from per-edge acceptance to staged maintenance of BFS layers. In dynamic external-memory BFS under monotone updates, the central rule is that the adjacency list for a vertex $O(n+m)$6 is added to the sorted pool $O(n+m)$7 when creating BFS level

$O(n+m)$8

of the updated graph. Each new BFS level of $O(n+m)$9 is then constructed by merging a subsequence of $Q$0, accounting for one BFS level in $Q$1, with $Q$2 using simple scanning. For decremental updates, the paper states the symmetric rule of applying a lag of $Q$3 levels instead of an advance. Its main theorem gives amortized

$Q$4

I/Os per update with high probability for sparse undirected graphs under monotone update sequences (0802.2847).

Semi-external BFS rephrases link iteration as repeated restructuring of a spanning tree. In EE-BFS, the algorithm scans every edge $Q$5 and, if $Q$6 is a V-BFS edge, makes $Q$7 the rightmost child of $Q$8. EB-BFS introduces a stipulation that, after traversing $Q$9, BFS first adds the nodes in $s$00 to its queue from the leftmost child of $s$01 on $s$02 to the rightmost child, and then adds $s$03 into $s$04 if $s$05, from front to back. EP-BFS retains only two attributes per node, $s$06 and $s$07, keeps an in-memory tree fragment $s$08, and filters edges using a threshold $s$09: an edge $s$10 is added to the in-memory edge set $s$11 if both endpoints satisfy $s$12 and $s$13, or if $s$14 is a V-BFS edge under the current tree. During EP-Reduce, the queue is simulated by indices

$s$15

and the algorithm pops $s$16, sets $s$17, and enqueues each unmarked out-neighbor while setting its parent (Wan et al., 17 Jul 2025).

The FOON-oriented paper (Shashwat, 2022) cannot presently support any technical encyclopedia treatment of a FOON-specific BFS link iteration rule. The supplied material states only that there is no PDF and no source to generate one, and explicitly provides no FOON graph traversal discussion, no BFS/GBFS/IDFS description, no stopping conditions, no pseudocode, and no experimental results. The only defensible conclusion is that any FOON-specific BFS link iteration rule attributed to that paper would be unsupported by the available text (Shashwat, 2022).