k-Truss: Edge-Centric Cohesive Subgraphs

• k-Truss is an edge-centric cohesive subgraph model defined by a minimum triangle count (k-2) per edge, ensuring robust triangle-supported cohesion.
• Truss decomposition employs a recursive peeling algorithm that assigns truss numbers based on triangle counts, enabling scalable and efficient computation.
• Advanced techniques extend k-Truss to dynamic, temporal, and higher-order settings, addressing challenges in maintenance, parallelization, and sparsity in large graphs.

Searching arXiv for recent and foundational k-truss papers to ground the article. A $k$-truss is an edge-centric cohesive subgraph model for a simple undirected unweighted graph $G=(V,E)$. In the standard convention used across much of the recent literature, a $k$-truss is a connected, maximal subgraph in which every edge participates in at least $k-2$ triangles within that subgraph; equivalently, if the support of an edge $(u,v)$ is the number of common neighbors of $u$ and $v$, then every retained edge satisfies $|N(u)\cap N(v)| \ge k-2$ after recursive peeling. The associated edge label is its truss number, the highest $k$ such that the edge belongs to a $k$-truss, and the maximum edge truss number in the graph is the truss degeneracy. In this sense, $G=(V,E)$0-truss is the edge-based analogue of $G=(V,E)$1-core: core decomposition assigns density indicators to vertices, whereas truss decomposition assigns triangle-based density indicators to edges (Liu et al., 2020).

1. Definition, support, and notation conventions

The standard decomposition view is support-based. For an edge $G=(V,E)$2, its support is the number of triangles containing $G=(V,E)$3, i.e. the number of common neighbors of $G=(V,E)$4 and $G=(V,E)$5. Truss decomposition first counts the triangles that each edge participates in, then peels edges in nondecreasing triangle count, assigning that count as the truss number and decrementing the triangle counts of neighboring edges when a triangle is broken. This makes trussness a recursively regularized version of raw triangle participation rather than a static local count (Liu et al., 2020).

A common source of confusion is parameterization. Most of the literature summarized here uses the threshold $G=(V,E)$6: a $G=(V,E)$7-truss requires every edge to lie in at least $G=(V,E)$8 triangles. By contrast, “Bounds and algorithms for graph trusses” adopts a shifted convention in which a $G=(V,E)$9-truss is a graph with no isolated vertices such that every edge is incident to at least $k$0 triangles; under that convention, a $k$1-clique is a $k$2-truss. The same work defines a $k$3-truss-component as a maximal edge set whose edge-induced subgraph is a connected $k$4-truss, and the trussness $k$5 of an edge as the maximum $k$6 such that $k$7 belongs to a $k$8-truss-component (Burkhardt et al., 2018).

This distinction is purely notational, but it affects every formula involving clique size, support thresholds, and extremal bounds. In the standard $k$9 convention, a $k-2$0-clique is also a $k-2$1-truss; in the shifted convention, the same clique is a $k-2$2-truss because “$k-2$3” already counts triangles rather than subtracting 2. Any technical comparison of papers therefore requires fixing the convention first.

2. Structural properties and relation to cores, cliques, and sparsity

The standard relation among dense subgraph models is explicit: if a subgraph is a $k-2$4-clique, then each vertex has degree $k-2$5 within the clique and each edge lies in $k-2$6 triangles within the clique; therefore a $k-2$7-clique is also a $k-2$8-core and a $k-2$9-truss. This is the local regime in which core numbers and truss numbers nearly coincide up to an additive constant. The same literature emphasizes the converse asymmetry: a large truss number of an edge implies large core numbers on its endpoints, but high coreness alone does not imply high trussness, because degree-based cohesion need not be triangle-supported (Liu et al., 2020).

Under the shifted convention of the extremal work, any vertex in a $(u,v)$0-truss has degree at least $(u,v)$1, the minimum number of vertices in a $(u,v)$2-truss is exactly $(u,v)$3, and the edge trussness satisfies $(u,v)$4, where $(u,v)$5 is graph degeneracy. That paper also proves nearly tight bounds on the minimum number of edges in a connected $(u,v)$6-truss. If $(u,v)$7 denotes the minimum number of edges in a connected $(u,v)$8-truss on $(u,v)$9 vertices, then

$u$0

and if $u$1, then

$u$2

The same paper defines a critical $u$3-truss as a $u$4-truss containing no proper nonempty edge-induced $u$5-truss and shows that even critical trusses can have only linear-in-$u$6 edge density: $u$7 These bounds make a central structural point: triangle-supported cohesion is stricter than core structure, but connected $u$8-trusses can still be globally sparse (Burkhardt et al., 2018).

This explains why $u$9-truss is often described as a relaxation of clique rather than as a dense graph in the ordinary edge-density sense. The local condition is highly constrained—every edge must be multiply reinforced by triangles—yet the global object may still be assembled from sparse interconnections of highly reinforced regions.

3. Decomposition algorithms and scalable implementations

The canonical decomposition algorithm is support peeling on edges. In the standard graph model $v$0, the decomposition proceeds in two phases: first count the number of triangles incident to each edge; then peel edges in nondecreasing triangle count, assigning that count as the truss number and decrementing the triangle counts of neighboring edges when a triangle is broken. The stated running time for this formulation is

$v$1

which already makes clear that the computational bottleneck is triangle handling rather than degree updates (Liu et al., 2020).

For moderate-size graphs, “Truss Decomposition in Massive Networks” improves the in-memory peeling strategy by scanning only the lower-degree endpoint neighborhood and using a hash table for constant-time edge existence tests. The resulting in-memory algorithm computes all $v$2-trusses in $v$3 time using $v$4 space. The same work develops bottom-up and top-down I/O-efficient algorithms for graphs that do not fit in main memory. The bottom-up method computes lower bounds on edge trussness via neighborhood subgraphs and then extracts candidate subgraphs for successive $v$5-classes; the top-down method uses upper bounds and is intended for computing only the top-$v$6 truss classes (Wang et al., 2012).

A separate line of work sharpens both combinatorial and algorithmic viewpoints. “Bounds and algorithms for graph trusses” gives a practical decomposition algorithm with $v$7 time and $v$8 memory, where

$v$9

and also develops a truncated decomposition algorithm based on fast matrix multiplication. The latter is primarily theoretical, but it shows that for small truncation thresholds $|N(u)\cap N(v)| \ge k-2$0, truss decomposition can be linked to dynamic triangle-generation data structures (Burkhardt et al., 2018).

Parallel implementations split into shared-memory and linear-algebraic families. PKT is a shared-memory OpenMP algorithm that performs level-synchronous peeling by processing all edges at the same support level in parallel, with careful ownership rules so that each triangle is effectively processed once; on 24 cores it achieves a geometric-mean relative speedup of $|N(u)\cap N(v)| \ge k-2$1 over its own single-thread time (Kabir et al., 2017). In the linear-algebraic direction, Eager K-truss represents support computation as

$|N(u)\cap N(v)| \ge k-2$2

repeated until convergence. A fine-grained formulation that parallelizes over nonzeros rather than source rows improves load balance and reported between $|N(u)\cap N(v)| \ge k-2$3–$|N(u)\cap N(v)| \ge k-2$4 on CPU and $|N(u)\cap N(v)| \ge k-2$5–$|N(u)\cap N(v)| \ge k-2$6 on GPU relative to the coarse-grained version (Blanco et al., 2020).

4. Dynamic maintenance, interventions, and complexity barriers

Dynamic truss maintenance studies how trussness changes under edge insertions and deletions. For a single-edge update $|N(u)\cap N(v)| \ge k-2$7, let $|N(u)\cap N(v)| \ge k-2$8 be the common-neighbor set. A core locality fact is that after one deletion or insertion, if an edge is affected, its truss number changes by at most $|N(u)\cap N(v)| \ge k-2$9. The same maintenance theory gives explicit affected truss ranges: under deletion, only edges with truss numbers in

$k$0

can be affected; under insertion, only edges with truss numbers in

$k$1

can be affected. At the same time, the propagation may extend arbitrarily far through the graph: there is no guarantee that the update effect ends after spreading a fixed number of steps (Zhou et al., 2014).

The intervention view of $k$2-truss treats triangle-supported subgraphs as a proxy for structural stability. In $k$3-truss minimization, given a budget $k$4, one selects $k$5 edges whose deletion maximizes the number of follower edges removed from the current $k$6-truss. Formally, if $k$7 denotes the followers of a deleted set $k$8, the objective is

$k$9

The problem is NP-hard for $k$0, and the follower-count objective is monotonic but not submodular. The resulting algorithms exploit support-threshold cascades, $k$1-support groups, and upper bounds derived from $k$2-truss groups to accelerate greedy search (Zhu et al., 2019).

Recent lower-bound work places strict limits on exact dynamic truss algorithms. The dynamic decision problem $k$3-TRUSS asks whether a fixed edge $k$4 belongs to the current $k$5-truss under edge insertions and deletions; the associated TRUSSVALUE problem asks for edge truss values dynamically. Conditional lower bounds show that, unless the OMv conjecture fails, there is no fully or partially dynamic TRUSSVALUE algorithm with preprocessing $k$6, update time $k$7, and query time $k$8; unless SETH fails, there is no such algorithm with both update and query time $k$9. The same work also proves that there exists no bounded algorithm in the RAM model for incremental full truss maintenance unless the OMv conjecture is false (Couto et al., 16 Sep 2025).

Taken together, these results separate two claims that are often conflated. Exact local maintenance rules are available and practically useful, but generic worst-case-efficient exact dynamic truss decomposition appears unlikely. This suggests why much empirical work concentrates on restricted update models, bounded affected regions in practice, or query-specific maintenance rather than universally fast fully dynamic algorithms.

5. Temporal and higher-order generalizations

A direct temporal generalization is the span-truss. For a temporal graph $G=(V,E)$00 and an interval $G=(V,E)$01, define the persistent edge set

$G=(V,E)$02

and the interval graph $G=(V,E)$03. The $G=(V,E)$04-truss, or span-truss, is the largest subgraph of $G=(V,E)$05 in which every edge is contained in at least $G=(V,E)$06 triangles within the subgraph, and it is denoted $G=(V,E)$07. A span-truss is maximal if there does not exist another span-truss $G=(V,E)$08 such that $G=(V,E)$09 and $G=(V,E)$10. For a fixed interval $G=(V,E)$11, finding all span-trusses is equivalent to computing the classic truss decomposition of $G=(V,E)$12; the algorithmic difficulty comes from the $G=(V,E)$13 interval family rather than from a different triangle definition (Lotito et al., 2020).

A second temporal model constrains triangles directly by time span rather than by graph persistence. In a temporal graph $G=(V,E)$14, the minimum time span of a triangle $G=(V,E)$15 is

$G=(V,E)$16

A triangle is a $G=(V,E)$17-triangle if $G=(V,E)$18, the $G=(V,E)$19-support of an edge is the number of $G=(V,E)$20-triangles containing it, and the $G=(V,E)$21-truss is the maximal subgraph in which every edge has $G=(V,E)$22-support at least $G=(V,E)$23. The original static $G=(V,E)$24-truss is recovered when $G=(V,E)$25. This family has a dual containment relation,

$G=(V,E)$26

which supports lossless indexes over all $G=(V,E)$27-trusses and dynamic index maintenance for temporal updates (Hu et al., 10 Jun 2026).

Higher-order generalizations replace direct common neighbors with multi-hop common neighborhoods. In the $G=(V,E)$28-truss model, the higher-order support of an edge $G=(V,E)$29 is

$G=(V,E)$30

where $G=(V,E)$31 is the $G=(V,E)$32-hop neighborhood of $G=(V,E)$33. A $G=(V,E)$34-truss is a maximal subgraph in which every edge satisfies $G=(V,E)$35. When $G=(V,E)$36, the model reduces to the classical $G=(V,E)$37-truss. The corresponding decomposition problem is substantially harder because support updates are no longer strictly local. HOTDecom and HOTDecom$G=(V,E)$38 therefore combine bottom-up peeling with delayed update, early pruning, and unchanged-support detection; empirically, HOTDecom$G=(V,E)$39 can be up to 4 orders of magnitude faster than the unoptimized baseline (Chen et al., 2021).

A parallel higher-order line uses an H-index fixed-point view rather than explicit peeling. For $G=(V,E)$40-truss, where standard $G=(V,E)$41-truss is the case $G=(V,E)$42, the edge values $G=(V,E)$43 are updated iteratively and shown to converge to $G=(V,E)$44. Asynchronous use of fresh values preserves monotonicity and convergence, and the optimized parallel framework reports up to 3 orders of magnitude speedup over the peeling baseline and up to $G=(V,E)$45 parallel speedup in some settings (Chen et al., 2024).

6. Interpretive uses, community models, and specialized settings

One influential interpretive use of $G=(V,E)$46-truss is to compare it directly with $G=(V,E)$47-core. The vertex interplay (VI) plot groups vertices by core number and summarizes the minimum and maximum trussness of their incident edges; the edge interplay (EI) plot groups edges by the core numbers of their endpoints and summarizes average trussness. These tools reveal domain-dependent discrepancies between degree-style density and triangle-style density. Collaboration networks often show near clique-like behavior, with minimum adjacent truss number, maximum adjacent truss number, and core number almost equal, whereas web graphs exhibit gatekeeper patterns in which vertices have high core number but all adjacent edges have very low trussness. The anomaly detector CORE-TRUSSDD operationalizes this discrepancy by clustering vertices via their truss-profile

$G=(V,E)$48

and then flagging clusterwise core-number outliers via Z-scores (Liu et al., 2020).

Query-oriented community models embed $G=(V,E)$49-truss inside richer feasibility constraints. In Attributed Truss Community (ATC) search, the feasible answer is a connected $G=(V,E)$50-truss containing the query vertices and satisfying a query-distance bound $G=(V,E)$51. Among such subgraphs, the objective is to maximize the attribute relevance score

$G=(V,E)$52

The optimization is NP-hard, and the score is neither submodular nor supermodular, so the proposed methods are greedy top-down shrinkage algorithms and an index-assisted local search procedure rather than approximation schemes (Huang et al., 2016).

Specialized graph models have also adapted truss decomposition to partial visibility. In a public-private graph, a user $G=(V,E)$53 sees a personalized graph

$G=(V,E)$54

where $G=(V,E)$55 is the public graph and $G=(V,E)$56 is the private edge set visible only to $G=(V,E)$57. The main computational problem is to answer $G=(V,E)$58-truss queries on $G=(V,E)$59 without recomputing from scratch. A node-insertion update framework derives lower and upper bounds on the trussness of newly inserted edges via $G=(V,E)$60-neighborhoods, then combines node-based and edge-based update strategies in a classifier-guided hybrid method (Ebadian et al., 2019).

Across these settings, a consistent theme emerges. Trussness is not merely a triangle count; it is the fixed point of recursive support preservation inside a surviving subgraph. That recursive aspect is why $G=(V,E)$61-truss often carries more structural information than raw support, why it diverges sharply from $G=(V,E)$62-core in gatekeeper or core-periphery regimes, and why it remains a central intermediate model between permissive degree-based cohesion and intractable clique-based density (Liu et al., 2020).