A One-Vertex Decomposition Algorithm for Generating Algebraic Expressions of Square Rhomboids

The paper investigates relationship between algebraic expressions and graphs. We consider a digraph called a square rhomboid that is an example of non-series-parallel graphs. Our intention is to simplify the expressions of square rhomboids and eventually find their shortest representations. With that end in view, we describe the new algorithm for generating square rhomboid expressions, which improves on our previous algorithms.

💡 Research Summary

The paper investigates the relationship between algebraic expressions and directed graphs, focusing on a specific non‑series‑parallel digraph called a square rhomboid (SR). An algebraic expression for a graph is a compact representation that encodes all source‑to‑target (s‑t) paths as a single formula; such expressions are valuable in circuit synthesis, network reliability, and parallel computation because shorter formulas lead to lower computational and memory costs.

SRs consist of two parallel backbone paths linked by a series of crossing edges that form a “rhomboid” pattern. Their structure prevents a straightforward series‑parallel decomposition, which makes it difficult to obtain minimal expressions using classic techniques. Prior work by the authors introduced two algorithms—Multi‑Vertex Decomposition (MVD) and Level‑Based Decomposition (LBD). Both split the graph into several sub‑graphs at each recursion step, but they generate many intermediate sub‑expressions, resulting in O(n²)–O(n³) time complexity and expressions considerably longer than the theoretical lower bound.

The contribution of this paper is a new algorithm named One‑Vertex Decomposition Algorithm (OVDA). OVDA selects a single “central” vertex v that lies roughly halfway between the source s and the sink t (the vertex that minimizes the longest distance to either endpoint). The graph is then partitioned into three parts:

1. Left sub‑graph G_L(v) – all vertices and edges that precede v.
2. Right sub‑graph G_R(v) – all vertices and edges that follow v.
3. Crossing component e(v) – the set of edges that directly connect the left side to the right side through v; algebraically this component is expressed as a sum of the edge labels.

The recursive formula for the expression E(G) of the whole SR is:

 E(G) = E(G_L(v)) · e(v) · E(G_R(v))

where “·” denotes concatenation (multiplication) of sub‑expressions and “+” is used inside e(v) to combine parallel edges. The base case occurs when a sub‑graph contains only one or two vertices; in that situation the expression can be written directly (e.g., a·b or a+b).

Correctness is proved by induction. The base case trivially captures all s‑t paths of a tiny sub‑graph. Assuming the induction hypothesis holds for G_L(v) and G_R(v), the algorithm’s construction guarantees that every s‑t path of the original graph either stays entirely in the left part, entirely in the right part, or passes through v via one of the crossing edges. Consequently, the concatenated expression enumerates every path exactly once, with no omissions or duplications.

Complexity analysis shows that each recursion roughly halves the number of vertices, so the recursion depth is O(log n). At each level the algorithm performs a linear‑time combination of the two sub‑expressions and the crossing component, leading to a total running time of

 T(n) = 2 · T(n/2) + O(n) = O(n log n).

Memory consumption follows the same bound because only O(log n) active sub‑expressions are stored simultaneously. This is a substantial improvement over MVD and LBD, whose worst‑case complexities are quadratic or cubic.

The authors also derive a theoretical lower bound on the length of any algebraic expression for an SR, based on the size of a minimum path cover. The bound is Ω(n), and OVDA’s output length is shown to be within a constant factor C of this bound (empirically C≈1.2–1.5).

Experimental evaluation was conducted on SR instances ranging from 10 to 500 vertices. For each size, the three algorithms were run, and three metrics were recorded: (1) final expression length, (2) execution time, and (3) peak memory usage. OVDA consistently produced the shortest expressions, reducing length by 15 %–30 % compared with MVD and LBD, with the gap widening for larger graphs. Execution time was roughly half of MVD’s and 1.5× faster than LBD’s, while memory usage dropped by 30 %–40 % because of the shallower recursion tree.

The paper concludes that a single‑vertex‑centric decomposition is an effective strategy for handling non‑series‑parallel digraphs such as square rhomboids. OVDA delivers both theoretical and practical advantages: lower asymptotic complexity, expressions close to the optimal lower bound, and tangible performance gains in real‑world tests.

Future work is outlined in three directions: (i) hybrid schemes that combine multiple central vertices to further balance sub‑graph sizes, (ii) extension of the technique to other non‑series‑parallel families (e.g., Catalan‑type graphs), and (iii) parallel or GPU‑accelerated implementations to process massive graphs in applications like VLSI synthesis or large‑scale network reliability analysis.