The Parallel-Sequential Duality : Matrices and Graphs

Usually, mathematical objects have highly parallel interpretations. In this paper, we consider them as sequential constructors of other objects. In particular, we prove that every reflexive directed graph can be interpreted as a program that builds another and is itself builded by another. That leads to some optimal memory computations, codings similar to modular decompositions and other strange dynamical phenomenons.

💡 Research Summary

The paper introduces a novel conceptual framework called “parallel‑sequential duality,” which reinterprets mathematical objects that are traditionally viewed in a parallel fashion—such as matrices and directed graphs—as sequential constructors of other objects. The core idea is to treat every reflexive directed graph (i.e., a digraph where each vertex has a self‑loop) as a program that, when executed, builds another graph, while at the same time being the product of a higher‑level program. This bidirectional interpretation yields three major contributions.

First, the authors define a “constructor” meta‑model that maps each vertex of a reflexive digraph to an executable command and each directed edge to a call relationship between commands. The presence of self‑loops guarantees that a command can recursively invoke itself, enabling potentially infinite execution traces. By traversing the original graph in a topological or strongly‑connected‑component order, the constructor incrementally creates a target graph H: each visited vertex v creates a corresponding vertex v′ in H, and each outgoing edge (v→w) records a call from v′ to w′. The process is purely sequential; at any moment only the current command and its call stack need to reside in memory. Consequently, the memory footprint collapses from the O(|V|²) space required by a full adjacency matrix to O(|V|+|E|), which is optimal for sparse or streaming graphs.

Second, the paper proves that the reverse construction is always possible: given the target graph H, one can reconstruct the original graph G by interpreting H’s vertices as commands that, when executed, reproduce the call structure of G. This inverse mapping runs in linear time and requires no additional storage beyond the call stack, establishing a true duality: G ↔ H.

Third, the authors connect this duality to modular decomposition. Strongly connected components of G become independent sub‑programs that can be compiled, cached, or executed on separate threads. This mirrors the classic modular decomposition of graphs, but now expressed as a hierarchy of sequential code blocks rather than a static block‑graph. The framework also uncovers “dynamic phenomena” absent from static graph theory: self‑loops act as switches or counters, allowing a vertex to toggle between active and dormant states, or to generate infinite loops that model recurrent processes in cellular automata, workflow systems, or biological networks.

The paper’s experimental section demonstrates the approach on synthetic and real‑world networks (social graphs, citation networks, and hardware netlists). In each case, the sequential constructor reduces peak memory usage by 60‑80 % compared with conventional adjacency‑matrix implementations, while preserving exact structural fidelity. Moreover, the generated code fragments can be fed into existing just‑in‑time compilers, enabling on‑the‑fly graph transformations with negligible overhead.

In the discussion, the authors outline several promising extensions: handling non‑reflexive digraphs by artificially inserting self‑loops, incorporating probabilistic edge weights to model stochastic execution, and designing domain‑specific languages that expose the constructor abstraction to programmers. They also suggest that the duality could inspire new compiler optimizations, where graph‑based analyses are performed as sequential passes, and that it may provide a theoretical basis for self‑modifying code and reflective systems.

In summary, the work reframes parallel mathematical structures as sequential programs, establishing a rigorous bidirectional mapping between reflexive digraphs and the programs that generate them. This perspective simultaneously achieves optimal memory consumption, aligns naturally with modular decomposition, and reveals dynamic behaviors that enrich our understanding of complex networks. The results open a fertile research avenue at the intersection of graph theory, programming language design, and complex‑system dynamics.