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 study addresses the computational intractability of large-scale motif discovery in networks with high-degree hub nodes, where combinatorial explosion severely limits existing approaches. To overcome this, we propose a fast scanning strategy that integrates k-core decomposition with isomorphic subtree counting, achieving efficient subgraph enumeration by prioritizing the traversal of peripheral network structures. Furthermore, we establish from a complexity-theoretic perspective that the key subroutine is #P-complete. This work breaks through the motif size limitations inherent in current algorithms. Experiments conducted on eleven real-world networks demonstrate that the proposed method substantially reduces computational overhead and improves solving efficiency, proving particularly effective for complex real-world networks characterized by rich peripheral structures.

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 study investigates the computational complexity classification of counting graph homomorphisms on planar graphs with non-negative weight matrices. Methodologically, it introduces an innovative element-wise logarithmic matrix algebra and integrates core techniques including holographic transformations, polynomial interpolation, and the FKT algorithm. The primary contributions are twofold: it rigorously establishes a complexity dichotomy between P and #P-hardness for positive definite and positive-entry matrices, thereby constructing a novel theoretical framework. Furthermore, this work lays a solid foundation for ultimately achieving a complete classification in the general non-negative weight matrix setting.

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.