Papers for

graph software developers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Efficient graph generation method cuts memory use and speeds training

Efficient Edge-aware Attention Network for Graph Generation

Abstract: Graph generative models commonly use graph-specific Transformer architectures to jointly update node and edge features. However, these architectures do not directly benefit from recent hardware-aware attention implementations, limiting their scalability. The adaptation is, however, non-trivial: edge and graph-level features must be injected into pairwise attention scores, graph masks must be respected, and dynamic edge updates remain a major source of quadratic memory usage. We propose an edge-aware attention layer for graph generation that incorporates structural information through head-wise score modulation, while updating edge representations with a lightweight residual mechanism that retains attention-score dependent edge updates. This layer can be effectively implemented using PyTorch's FlexAttention. We achieve similar generation quality to our baseline while reducing peak GPU memory by around 65% and substantially improving training and sampling throughput. These results suggest that the proposed architecture is a practical step toward scalable graph foundation models.

Tue 20 OctMachine Learning
The gist
Generating graphs on computers often involves using special attention methods that look at how nodes and edges relate. These methods can require a lot of memory and run slowly because of how they handle edges and masks. The authors propose a new way to do attention on graphs that uses less memory by cleverly adjusting how it scores connections and updates edges. Their approach keeps the quality of generated graphs while making the process much faster and more efficient on common hardware.
Open → 2610.28618v1

Additive approximation for generalized Turán problems is NP-hard

NP-hardness of additive approximation for generalized Turán problems

Abstract: For a fixed graph $T$ and a fixed nonempty family $\mathcal{F}$ of graphs, let $\operatorname{ex}(G, T, \mathcal{F})$ denote the maximum number of copies of $T$ in an $\mathcal{F}$-free subgraph of a graph $G$. Alon and Shikhelman~[Algorithmica, 2022] conjectured that if $e(T)> 0$ and no member of $\mathcal{F}$ is a subgraph of a blow-up of $T$, then for every $\varepsilon>0$, approximating $\operatorname{ex}(G, T, \mathcal{F})$ within an additive error $n^{v(T)-\varepsilon}$ is NP-hard for an input graph $G$ on $n$ vertices. The previously established general cases for this conjecture include $\operatorname{ex}(G, K_2, \mathcal{F})$ by Alon, Shapira and Sudakov~[Ann. of Math., 2009], and $\operatorname{ex}(G, K_m, K_k)$ by Alon and Shikhelman. In this paper, we confirm this conjecture for every bipartite graph $T$ and every clique $T$. Our reductions use iterative leaf additions, symmetric rooted extensions and random transversals to encode the maximum number of edges in a $(k-1)$-colorable subgraph of $G$, where $k=\min_{F\in \mathcal{F}}χ(F)$.

Mon 12 OctComputational Complexity
The gist
This paper studies a problem in graph theory where you want to find the largest subgraph of a given graph without certain forbidden patterns, while counting specific smaller subgraphs inside it. The authors show that approximating this count closely is computationally very hard (NP-hard) for a wide range of cases involving bipartite graphs and cliques. They confirm a previous conjecture about the difficulty of this problem by building complex reductions based on coloring properties of graphs. Essentially, it means no efficient algorithm can guarantee near-exact solutions for these problems unless a major breakthrough in computer science occurs.
Open → 2610.16358v1

K-core problem shows limits of parallel algorithms on special graphs

Sub-polynomial parameterized complexity of $k$-core

Abstract: The $k$-core of a graph is its (unique) largest subgraph with minimum degree at least $k$. For any $k \geq 3$, deciding whether a given vertex belongs to the $k$-core is a P-complete problem, meaning that it is inherently sequential and highly unlikely to admit efficient parallel algorithms, even on graphs of maximum degree $k+1$. This paper investigates alternative parameterizations of the $k$-core problem to identify conditions under which it can be placed into sub-polynomial complexity classes. We prove that the problem is in para-NC$^{2+ε}$ when parameterized by treewidth, and in para-NC$^3$ when parameterized by $k$ on chordal graphs. Furthermore, we introduce a novel NC$^{3}$ algorithm for interval graphs when $k = \mathcal{O}(\lg v(G))$, which relies on an improved parameterization by pathwidth. Finally, we establish corresponding lower bounds, demonstrating that, even with these parameterizations, computing the $k$-core remains L-hard, meaning it requires at least logarithmic space. These findings explore the boundary of parallel tractability for the $k$-core problem by highlighting the graph parameters that make it inherently sequential.

Mon 21 SeptComputational Complexity
The gist
The k-core of a graph is a group of connected points where each has at least k friends in the group. Figuring out if a particular point is in this group is usually a slow, step-by-step problem that can't be done quickly in parallel for large graphs. The authors looked at special graph shapes to find when this problem can be solved faster using parallel computing. They found that under certain conditions, like special ways to measure graph complexity called treewidth and pathwidth, the problem becomes easier to solve in parallel, but it still needs some minimum amount of memory.
Open → 2609.25419v1