algebraic subgraph counting

This work addresses the challenge of efficiently handling non-tree edge constraints and injective mappings in subgraph isomorphism counting. The authors propose a novel candidate tree–based framework that, for the first time, algebraically embeds non-tree edge constraints directly into the candidate tree structure. By leveraging matrix operations, the method enables efficient subgraph homomorphism counting and incorporates local sampling to enforce injectivity—eliminating the need for learning-based approaches or global sampling. The resulting algorithm scales polynomially to graphs with billions of edges and significantly outperforms existing methods across multiple datasets. Notably, as a non-learning approach, it achieves average accuracy more than an order of magnitude higher than FlowSC, the current state-of-the-art learning-based method.

This paper investigates constant-space algorithms for counting homomorphisms, subgraph isomorphisms, and induced subgraph isomorphisms of a fixed pattern graph in *d*-degenerate graphs. It introduces a novel graph parameter—*DAG-tree depth*—and combines it with DAG-tree width to design efficient divide-and-conquer and dynamic programming algorithms under the unit-cost RAM model. The work achieves the first constant-space subgraph counting algorithm for sparse pattern graphs; provides a complete induced-subgraph characterization for graphs with DAG-tree depth ≤ 2; attains *O*(*n*³) time with constant space for all pattern graphs on at most nine vertices; and reaches *O*(*n*²) time for induced subgraph counting when the pattern has at most eleven vertices. The core innovation lies in establishing DAG-tree depth as a new structural dimension for sparse graphs and proving its tight connection to low-space computational tractability.

This work addresses the subgraph counting problem on bounded-degeneracy graphs, focusing on arbitrary pattern graphs with at most nine vertices and cycles of length at most ten. We propose the first unified framework that reduces subgraph counting on degenerate graphs to counting small hypergraphs, integrating degeneracy ordering, hierarchical sampling, and hypergraph reduction techniques. Our method achieves the first subquadratic-time algorithms for counting any pattern graph on ≤9 vertices, with time complexity $ ilde{O}(n^{5/3})$, and extends subquadratic-time cycle counting to all cycles of length ≤10—resolving a long-standing open case. This establishes the first systematic subquadratic algorithmic theory for subgraph counting on bounded-degeneracy graphs, significantly extending the applicability boundary of the classical Chiba–Nishizeki paradigm.

This paper addresses the problem of efficiently maintaining the count of 4-cycles in fully dynamic graphs under frequent edge insertions and deletions. We propose the first algorithm to break the classical $O(m^{2/3})$ worst-case update-time barrier, leveraging fast matrix multiplication ($omega = 2.371339$), dynamic graph maintenance techniques, and tensor contraction. Our method achieves a worst-case update time of $O(m^{0.659}) = O(m^{2/3 - varepsilon})$, where $varepsilon > 0$ is explicitly computable. This result provides the first rigorous proof that the $O(m^{2/3})$ bound is not tight, narrowing the theoretical gap from $m^{2/3}$ toward $m^{1/2}$. It establishes a new complexity benchmark for dynamic subgraph counting, with direct implications for database query optimization, social network analysis, and biological network modeling.

This work resolves the Faben–Jerrum conjecture, which posits that the computational complexity of counting graph homomorphisms modulo a prime $p$ coincides with that of exact counting, unless the target graph admits certain nontrivial automorphisms. Leveraging a synthesis of algebraic graph theory, group action analysis, and modular arithmetic reduction techniques, we provide the first complete proof of the conjecture and extend the modular counting reduction framework from graph homomorphisms to general constraint satisfaction problems (#$_p$CSP). Our main contributions are: (1) a full dichotomy classification for modular graph homomorphism counting—establishing completeness for either $mathsf{P}$ or $#mathsf{_pP}$; (2) the first generic reduction method applicable to arbitrary #$_p$CSPs; and (3) a precise characterization showing that automorphism structure fundamentally governs tractability in modular counting. These results furnish foundational tools and a systematic complexity-theoretic characterization for modular counting.

This work addresses the enumeration and listing of projected tree patterns in graphs—a generalization of subgraph isomorphism central to database querying. We present the first efficient enumeration algorithm featuring polynomial preprocessing time and polylogarithmic delay. Under natural conditions, we establish a general equivalence between enumeration and listing for this problem. Our approach integrates fast (rectangular and output-sensitive) matrix multiplication, parameterized analysis via submodular width, and fine-grained complexity lower bounds. For a projected tree with $k$ nodes, the algorithm achieves $\tilde{O}(n^{17.42})$ preprocessing time and polylogarithmic delay, and extends to hypergraphs with preprocessing time $\tilde{O}(m^{17.42 \cdot \text{subw}(H)})$, where $\text{subw}(H)$ denotes the submodular width of the hypergraph $H$.

This paper investigates the computational and parameterized complexity of homomorphisms on ordered graphs—graphs whose vertices are equipped with a linear order. Methodologically, it employs reduction techniques—including an embedding of unordered graphs into ordered bipartite graphs—to establish NP-completeness and to show that the problem lies in XP but is W[1]-hard when parameterized by the number of vertices in the target graph. The main contribution is the first systematic complexity classification framework for ordered graph homomorphisms, identifying key tractable subclasses—such as ordered interval graphs and ordered convex graphs—for which the problem is solvable in polynomial time. The paper further designs efficient algorithms for these classes and reveals the fundamental role of vertex ordering: while it can induce complexity jumps (e.g., from P to NP-hard), it also enables novel algorithmic approaches unavailable in the unordered setting.

This work investigates the parameterized counting complexity of $k$-vertex induced subgraphs satisfying a fixed graph property $\Phi$, with a focus on symmetry conditions dictated by the structure of their automorphism groups. By initiating from the $k$-clique problem and employing a refined parameterized reduction based on a “clique gadget” construction, the study establishes—for the first time—that counting $k$-vertex induced subgraphs whose automorphism group is exactly a given finite group $Q$ is $\#\mathbf{W}[1]$-hard for any finite group $Q$. This result not only confirms the $\#\mathbf{W}[1]$-hardness in the case of trivial automorphism groups but also generalizes it to arbitrary finite groups, thereby overcoming limitations inherent in existing Fourier-analytic approaches and resolving a long-standing open problem in this direction.

This paper addresses several classical #P-hard counting problems: Hamiltonian path counting in undirected/directed bipartite graphs, permanent computation of {0,1}-matrices (i.e., perfect matching counting), k-star partition counting, and maximum matching counting in general graphs. We propose the first unified exact algorithmic framework based on the Matrix-Tree Theorem and root-of-unity filtering. Our method integrates generating functions with the Gallai–Edmonds decomposition to achieve structural sensitivity in time complexity optimization. Specifically, perfect matching counting nearly matches Ryser’s algorithm’s optimality; k-star partition counting runs in O*((1+εₖ)ⁿ); and Hamiltonian path counting achieves the first single-exponential-time algorithm for directed bipartite graphs. All algorithms operate in polynomial space, offering simplicity, extensibility, and practicality. This work marks the first systematic application of algebraic combinatorial tools—particularly matrix-theoretic and algebraic-numeric techniques—to unify the exact solution of diverse graph counting problems.

This work addresses the need for efficient higher-order structural analysis in complex networks by studying the counting of hypertriangles—patterns formed by three pairwise-intersecting hyperedges—in hypergraphs. Inspired by graph orientation and degeneracy-based algorithms, the authors generalize the concepts of graph orientation and degeneracy ordering to hypergraphs for the first time, proposing DITCH, a provably efficient counting algorithm. DITCH integrates hypergraph orientation, degeneracy ordering, and combinatorial enumeration to effectively handle the diverse intersection structures inherent in hypertriangles. Experimental results demonstrate that DITCH achieves speedups of 10–100× over state-of-the-art methods while substantially reducing memory consumption.