Parallel Flipping: Concepts & Applications

• Parallel flipping is a collection of flip-based operations defined differently in combinatorial, geometric, algebraic, and coding theory contexts.
• It is applied in domains such as 3D domino tilings, lattice triangulations, spanning trees, and LDPC decoding, each with unique rules for local or simultaneous execution.
• These approaches enhance algorithmic performance by enabling concurrent local updates, efficient flip plan constructions, and improved error-correction capabilities in decoding.

Parallel flipping is not a single formalism but a cluster of flip-based notions whose meaning depends on the underlying combinatorial, geometric, algebraic, or coding-theoretic object. In the cited literature, “parallel” may refer to the two dominoes in a local tiling move being parallel, to a geometric family of edges in a non-crossing tree, to simultaneous levels of a flip plan in a lattice triangulation, to concurrent traversal of a flip graph, or to bit-flipping decoders and decoder ensembles that act in parallel on the same syndrome or received word (Milet et al., 2014, Bousquet et al., 2023, Sims et al., 2020, Jordan et al., 2017, Santini et al., 2019, Nguyen et al., 2012, Chytas et al., 2024).

1. Terminological range

The literature uses the phrase in several non-equivalent ways.

Setting	Flip object	Meaning of “parallel”
3D domino tilings	Local domino replacement	The two dominoes in the move are parallel
Non-crossing spanning trees	Single-edge flip sequence	“Parallel edges” is geometric, not simultaneous execution
Lattice triangulations	Diagonal flips in a poset	Flips in one level can be performed simultaneously
Regular triangulation enumeration	Reverse search over flip neighbors	Parallelism is concurrent subtree exploration
LDPC/MDPC/QLDPC decoding	Bit-flipping updates or decoder ensembles	Bits or decoders act simultaneously
In-place permutation	Disjoint transpositions from involutions	Each involution is one parallel swap round

A recurring source of confusion is the assumption that every occurrence of “parallel” refers to simultaneous execution of independent local flips. Several papers explicitly rule this out. The non-crossing spanning-tree paper studies single-edge flips only and states that it does not define or analyze parallel flips, simultaneous flips, independent flips performed in one round, round complexity, commuting flips, or batched flips (Bousquet et al., 2023). The paper on plane spanning paths likewise does not introduce a model of parallel rounds, although it develops local validity conditions for individual flips (Aichholzer et al., 2022). By contrast, the lattice-triangulation paper treats simultaneous flipping as a consequence of a poset structure on shortest flip paths (Sims et al., 2020).

2. Local geometric flips and parallel objects

In three-dimensional domino tilings, a flip is the local move performed by removing two parallel dominoes and placing them back in the only other possible position. The setting is a class of regions of the form $D+[0,N]$, with duplex regions corresponding to $N=2$. For tilings $t$ of duplex regions, the note proves the identity

$\operatorname{Tw}(t)=P_t'(1),$

where $\operatorname{Tw}(t)$ is the common value of the pretwists $T^{\vec i}(t)=T^{\vec j}(t)=T^{\vec k}(t)$, and this quantity is known to be invariant under flips. The paper encodes duplex tilings by planar “socks,” in which cycles represent horizontal structure and jewels represent vertical dominoes; several tilings may correspond to the same sock and lie in the same flip-connected component (Milet et al., 2014).

For non-crossing spanning trees on $n$ points in convex position, a flip consists in adding an edge and removing another so that the result is again a non-crossing spanning tree. The paper improves the general upper bound on sequential flip distance to $2n-\sqrt n+1$, proves a $\frac32 n$ bound when one tree is a path, and gives specialized bounds when one tree has a long subpath or many parallel edges. Here “parallel” means a geometric configuration of edges

$a_1b_1,\ldots,a_tb_t$

whose endpoints occur in cyclic order

$N=2$0

not simultaneous or batched execution. The paper states that it provides no direct theorem for true parallel flipping (Bousquet et al., 2023).

For plane straight-line spanning paths, a flip replaces one edge of a path by another so that the result is again a plane spanning path. The paper distinguishes three flip types, proves that it is enough to study paths with fixed first edge, and establishes connectivity for wheel sets and generalized double circles, with diameter at most $N=2$1 in the wheel case and $N=2$2 in the generalized-double-circle case. Its arguments are explicitly sequential: some local moves are valid only when performed subsequently after another flip, and the paper does not define a parallel-round semantics (Aichholzer et al., 2022).

3. Simultaneous flipping in lattice triangulations

For lattice triangulations, the central structural object is the minimum flip plan, a poset of flips such that all of its consistent linear orderings are flip paths between the same two triangulations. The paper’s main theorem states that the shortest constrained flip path between two lattice triangulations is unique, up to reordering flips. This turns shortest-path structure into a dependency poset rather than a single sequence (Sims et al., 2020).

The paper is the most explicit source on simultaneous flipping among the cited works. It states that all the flips in each level of a flip plan can be performed simultaneously, and it discusses optimal simultaneous flip paths in terms of the height of the least-restrictive minimum flip plan. Its fully proved results concern shortest sequential flip paths and the construction of minimum flip plans via Farey plans and Farey parallelograms; the conclusion then states that the least-restrictive minimum flip plan is unique and of minimum height, and that both the size and height of these plans are metrics on the space of lattice triangulations. In this sense, size measures minimum total flips, while height measures minimum simultaneous rounds. Algorithmically, the paper gives $N=2$3 time for a minimum flip plan forcing one point-pair to become an edge, $N=2$4 time for a set $N=2$5 of point-pairs, and $N=2$6 time for rectangular lattice point sets (Sims et al., 2020).

4. Parallel traversal of flip spaces

A different use of the term appears in the enumeration of regular triangulations. The algorithm called down-flip reverse search traverses the flip graph of triangulations by orienting flips through a total order induced by GKZ-vectors. A flip $N=2$7 is an up-flip if $N=2$8 and a down-flip if $N=2$9. Reverse search uses regular down-flip neighbors as adjacency and defines the parent $t$0 as the maximal triangulation obtainable from $t$1 by an up-flip, with a unique root $t$2 (Jordan et al., 2017).

The parallelism here does not come from simultaneously applying several compatible flips inside one triangulation. It comes from exploring many branches of the reverse-search tree concurrently. The implementation uses budgeted reverse search within the MPI-based framework mts: workers explore subtrees depth-first, report unexplored frontier nodes when budgets are exhausted, and the master redistributes those nodes. Because reverse search avoids a global visited set, communication is minimal. The paper emphasizes that this is what makes parallel reverse search so successful. In this sense, “parallel flipping” means parallel traversal of a flip-induced state space. The implementation is reported to enumerate much larger triangulation spaces than before; for example, it computes $t$3 orbits of regular and full triangulations of $t$4 using 40 threads in about four days (Jordan et al., 2017).

5. Parallel bit flipping in classical coding theory

In LDPC decoding over the BSC, standard parallel bit flipping updates all candidate variable nodes simultaneously. For a variable node $t$5, the classical rule flips $t$6 if

$t$7

where $t$8 and $t$9 are the numbers of unsatisfied and satisfied neighboring checks. The paper on two-bit bit flipping replaces the binary state $\operatorname{Tw}(t)=P_t'(1),$0 by

$\operatorname{Tw}(t)=P_t'(1),$1

so that a variable carries both a hard value and a “strength.” An additional check-node bit may distinguish previously satisfied, previously unsatisfied, newly satisfied, and newly unsatisfied checks. For 3-left-regular codes with girth $\operatorname{Tw}(t)=P_t'(1),$2 and no codeword of weight $\operatorname{Tw}(t)=P_t'(1),$3, TBFA1 is stated to correct any error pattern with up to $\operatorname{Tw}(t)=P_t'(1),$4 errors, while the guaranteed correction capability of the ordinary parallel bit flipping algorithm is strictly less than $\operatorname{Tw}(t)=P_t'(1),$5; the paper therefore states that the new class increases guaranteed correction capability by a factor of at least 2 (Nguyen et al., 2011).

A complementary line of work studies parallel BF through rigorous one-iteration analysis for LDPC and MDPC codes. In that model, for each bit $\operatorname{Tw}(t)=P_t'(1),$6, the decoder counts the number of unsatisfied parity checks

$\operatorname{Tw}(t)=P_t'(1),$7

and flips all bits with $\operatorname{Tw}(t)=P_t'(1),$8 simultaneously. The paper gives deterministic one-iteration correction guarantees via the overlap parameter $\operatorname{Tw}(t)=P_t'(1),$9, and an exact per-code one-iteration upper bound on failure probability based on counting bad subsets in the row-wise overlap vectors $\operatorname{Tw}(t)$0. This is motivated in part by code-based cryptography, where decryption-failure rates below $\operatorname{Tw}(t)$1 are required and Monte Carlo validation is infeasible (Santini et al., 2019).

Parallelism can also be lifted from bits to decoder ensembles. In the work on selecting two-bit bit flipping algorithms, several TBF decoders operate in parallel on the same received vector. The selection criterion is complementarity of trapping set profiles: one chooses individually strong algorithms whose minimal uncorrectable configurations differ. In the example for column-weight-three regular LDPC codes with girth $\operatorname{Tw}(t)$2, the constrained search space contains $\operatorname{Tw}(t)$3 TBF algorithms, $\operatorname{Tw}(t)$4 of which correct every weight-three error pattern, and the paper ultimately selects 35 algorithms to operate in parallel (Nguyen et al., 2012).

6. Collective parallel flipping for quantum LDPC codes

For variable-degree-3 QLDPC codes, the collective bit-flipping framework replaces a single BF rule by a set of two-bit bit-flipping decoders that run in parallel on the same syndrome. In the baseline syndrome-based BF decoder, a variable node $\operatorname{Tw}(t)$5 is flipped if

$\operatorname{Tw}(t)$6

so for $\operatorname{Tw}(t)$7 any variable with at least two unsatisfied neighboring checks is flipped. The paper argues that this is too crude for generalized hypergraph-product codes because 6-cycles generate classical trapping sets and 8-cycles generate $\operatorname{Tw}(t)$8 quantum trapping sets that are symmetric stabilizers (Chytas et al., 2024).

The proposed TBF decoders enrich both variable-node and check-node state. Variable nodes take values in $\operatorname{Tw}(t)$9, with the most significant bit representing the hard decision and the least significant bit the strength; check nodes take values in $T^{\vec i}(t)=T^{\vec j}(t)=T^{\vec k}(t)$0. Distinct decoders $T^{\vec i}(t)=T^{\vec j}(t)=T^{\vec k}(t)$1 differ by initialization, local overrides, and, in some cases, different $T^{\vec i}(t)=T^{\vec j}(t)=T^{\vec k}(t)$2 tables on different circulant subsets, thereby intentionally breaking symmetry. The paper constructs sets such as $T^{\vec i}(t)=T^{\vec j}(t)=T^{\vec k}(t)$3 and $T^{\vec i}(t)=T^{\vec j}(t)=T^{\vec k}(t)$4; the latter is designed to correct all error patterns up to weight 5 inside the major classical trapping-set families and all error patterns inside the $T^{\vec i}(t)=T^{\vec j}(t)=T^{\vec k}(t)$5 quantum trapping sets. Empirically, $T^{\vec i}(t)=T^{\vec j}(t)=T^{\vec k}(t)$6 surpasses layered normalized min-sum in the error-floor region for the $T^{\vec i}(t)=T^{\vec j}(t)=T^{\vec k}(t)$7 code, surpasses normalized min-sum for the $T^{\vec i}(t)=T^{\vec j}(t)=T^{\vec k}(t)$8 code, and at crossover probability $T^{\vec i}(t)=T^{\vec j}(t)=T^{\vec k}(t)$9 achieves about 1000 times better performance than nMS while requiring about 2.5 average iterations, compared with 1.2 for nMS (Chytas et al., 2024).

7. Generalized and adjacent meanings

The language of flips also extends beyond simultaneous local reconfiguration. In the theory of finite posets, a flip on a poset $n$0 is defined from a partition $n$1 with no $n$2 above any $n$3, by reversing all cover relations across the partition while keeping internal covers unchanged. When $n$4 is a lattice, a flip is a mutation if the resulting poset is again a lattice, and the paper proves the exact criterion

$n$5

The same work introduces locally mutable and mutable lattices, proves that mutable lattices are semidistributive, and studies Cambrian and Ordovician lattices under sequences of mutations. It does not define simultaneous or parallel flips, but its notions of fault planes, boundary sublattices, quotient descent, and factorization into BGP-reflections provide a locality structure that is suggestive for any future theory of independent or commuting flips (Nagano, 10 May 2026).

A still broader adjacent meaning appears in in-place permutation and perfect shuffling. Every permutation of $n$6 can be written as the product of two involutions, and since an involution is a product of disjoint transpositions and fixed points, each involution can be executed as one round of pairwise independent swaps. The paper therefore states that any array permutation can be performed in-place in parallel in time $n$7. For the $n$8-way perfect shuffle with $n$9, it gives the explicit factorization

$2n-\sqrt n+1$0

with sequential time $2n-\sqrt n+1$1 and space $2n-\sqrt n+1$2; for general $2n-\sqrt n+1$3 a multiple of $2n-\sqrt n+1$4, it gives a number-theoretic involution pair with time $2n-\sqrt n+1$5 and the same space bound (Yang et al., 2012).

Taken together, these usages show that “parallel flipping” designates several structurally different ideas rather than a single canonical operation. This suggests that any unified theory would have to distinguish at least four notions: local flips involving parallel geometric objects, genuinely simultaneous compatible flips, parallel search through flip graphs, and parallel ensembles of local update rules or swap stages. The cited literature treats all four, but only in domain-specific form.