Fast Triangle Detection and Enumeration in Undirected Graphs: The Aegypti Algorithm

1. Introduction

Let $G=(V,E)$ be a simple undirected graph with $n=\left|V\right|$ vertices and $m=\left|E\right|$ edges. A triangle is a set of three distinct vertices $\{u,v,w\}\subseteq V$ such that $\left\{\right(u,v),(v,w),(w,u\left)\right\}\subseteq E$. We denote the set of all triangles in G by $\mathcal{T}\left(G\right)$ and let $t=\left|\mathcal{T}\right(G\left)\right|$ denote the triangle count.

We address two variants:

1.

Triangle Enumeration: List all $\tau \in \mathcal{T}\left(G\right)$.

2.

Triangle Detection: Determine whether $\mathcal{T}\left(G\right)\ne \varnothing$ and return a single witness $\tau \in \mathcal{T}\left(G\right)$ if one exists.

Traditional approaches to triangle detection range from brute-force $O\left(n^3\right)$ enumeration to matrix-multiplication-based methods running in $O\left(n^{\omega }\right)$ time, where $\omega <2.373$ is the fast matrix multiplication exponent [1]. Conditional lower bounds suggest $\mathsf{\Omega }\left(m^{4/3}\right)$ for detection under 3SUM-hardness conjectures [2]. The practical state of the art for listing relies on degeneracy ordering, as analyzed by Chiba and Nishizeki [3], which bounds execution by the graph’s arboricity $\alpha \left(G\right)$ and yields a runtime of $\mathcal{O}(m·\alpha \left(G\right))\subseteq \mathcal{O}\left(m^{3/2}\right)$.

We introduce Aegypti, an adaptive algorithm available as the Python package aegypti (version 0.3.7) [4]. Aegypti switches execution paths based on graph density $\delta =2m/\left(n\right(n-1\left)\right)$ to minimize overhead, achieving $\mathcal{O}\left(m^{3/2}\right)$ enumeration and fast detection in practice.

2. The Aegypti Algorithm

The core design of Aegypti is the dynamic selection between two established paradigms—Edge-Iterator with Intersection (Sparse Branch) and Vertex-Iterator with Forward-Marking (Dense Branch)—both governed by a global descending degree sort.

2.1. Notation

Throughout this paper we use the following notation. For a vertex $v\in V$, let $d\left(v\right)$ denote its degree and $d_{max}={max}_{v\in V}d\left(v\right)$ the maximum degree. We write $\mathrm{id}\left(v\right)$ for an arbitrary but fixed vertex identifier. We define a total ordering ≺ on V by

$$u\prec v\iff d\left(u\right)>d\left(v\right)\mathrm{or}\left(d\left(u\right)=d\left(v\right)\mathrm{and}\mathrm{id}\left(u\right)<\mathrm{id}\left(v\right)\right).$$

Let $\pi :V\to \{0,\dots ,n-1\}$ be the rank under ≺, so that $\pi \left(v\right)=0$ for the highest-degree vertex $v_{max}$. For a vertex u, its adjacency set is $\mathrm{Adj}\left[u\right]=\{v\in V:(u,v)\in E\}$. For the Dense Branch we define forward neighbors of u as $N_u^{+}=\{v\in \mathrm{Adj}\left[u\right]:v\mathrm{not}\mathrm{yet}\mathrm{marked}\mathrm{from}u\}$ (see Algorithm 1, lines 17–22). The local clustering coefficient of v is $C\left(v\right)=\left|\{(a,b)\in E:a,b\in \mathrm{Adj}\left[v\right]\}\right|/\left({\displaystyle \genfrac{}{}{0pt}{}{d\left(v\right)}{2}}\right)$ for $d\left(v\right)\ge 2$, and $C\left(v\right)=0$ otherwise. We let $\alpha \left(G\right)$ denote the arboricity of G, defined as $\alpha \left(G\right)={max}_{H\subseteq G,\left|V\right(H\left)\right|\ge 2}\lceil \left|E\left(H\right)\right|/\left(\right|V\left(H\right)|-1)\rceil$; it satisfies $\alpha \left(G\right)\le \sqrt{m}$.

2.2. Algorithm Specification

Algorithm 1 Adaptive Triangle Enumeration and Detection

3. Theoretical Analysis

3.1. Correctness

Lemma 1

(Duplicate Avoidance). Algorithm 1 enumerates each triangle $\tau \in \mathcal{T}\left(G\right)$ exactly once.

Proof. 

Let $\tau =\{x,y,z\}$ be a triangle with $\pi \left(x\right)<\pi \left(y\right)<\pi \left(z\right)$.

Sparse Branch. The outer loops only process pairs $(u,v)$ with $\pi \left(u\right)<\pi \left(v\right)$. When $u=x$, $v=y$, the set $S=\mathrm{Adj}\left[x\right]\cap \mathrm{Adj}\left[y\right]$ contains z, and the inner condition $\pi \left(y\right)<\pi \left(w\right)$ selects $w=z$. No other assignment of roles to $x,y,z$ satisfies all three strict rank conditions simultaneously, so $\tau$ is yielded exactly once.

Dense Branch. When processing $u=x$, forward neighbors $N_x^{+}$ are accumulated from $\mathrm{Adj}\left[x\right]$ filtered by the marking set; y and z are both added to $N_x^{+}$ (since neither has been marked from x at this point). The pair check then tests $(y,z)\in E$, which holds. Processing $u=y$ or $u=z$ cannot re-generate $\tau$: by the time y is processed, x is already in $\mathrm{Marked}\left[y\right]$, so $x\notin N_y^{+}$. Thus $\tau$ is yielded exactly once, when $u=x$.    □

Lemma 2

(Completeness). Every triangle $\tau \in \mathcal{T}\left(G\right)$ is yielded by Algorithm 1.

Proof. 

Let $\tau =\{x,y,z\}$ with $\pi \left(x\right)<\pi \left(y\right)<\pi \left(z\right)$. In both branches, when $u=x$ is processed, y and z are neighbors of x with higher rank, and the edge $(y,z)$ is present. In the Sparse Branch, $z\in S=\mathrm{Adj}\left[x\right]\cap \mathrm{Adj}\left[y\right]$ is found when processing pair $(x,y)$. In the Dense Branch, both y and z are added to $N_x^{+}$ (no prior processing of x’s edges has inserted them into $\mathrm{Marked}\left[x\right]$), and the edge check at the pair $(y,z)$ succeeds.    □

3.2. Complexity Analysis: Enumeration

Theorem 1

(Enumeration Complexity). The total runtime of Algorithm 1 for full enumeration is

$$T_{\mathrm{list}}\left(G\right)=\mathcal{O}(nlogn+m\alpha \left(G\right)+t),$$

where $t=\left|\mathcal{T}\right(G\left)\right|$ is the number of triangles. In particular, $T_{\mathrm{list}}\left(G\right)\subseteq \mathcal{O}(nlogn+m^{3/2}+t)$.

Proof. 

Sorting requires $\mathcal{O}(nlogn)$. For both branches, the dominant cost is proportional to the number of pairs $(v,w)$ that are examined as candidate pairs sharing a common neighbor u. By the analysis of Chiba and Nishizeki [3], an edge-oriented traversal under degree ordering incurs cost ${\sum }_{(u,v)\in E}min(d\left(u\right),d\left(v\right))\le 2m\alpha \left(G\right)$. Every yielded triangle contributes $\mathcal{O}\left(1\right)$ per output. Since $\alpha \left(G\right)\le \sqrt{m}$, we have $m\alpha \left(G\right)\le m^{3/2}$.    □

3.3. Complexity Analysis: Detection

We now analyze the case $\mathrm{first}\_\mathrm{triangle}=\mathrm{True}$.

Theorem 2

(Detection Complexity). Let $T_{\mathrm{sort}}=\mathcal{O}(nlogn)$ denote the preprocessing time to order vertices by non-increasing degree, and let $T_{\mathrm{search}}$ be the subsequent search time. The total detection time is $T_{\mathrm{detect}}=T_{\mathrm{sort}}+T_{\mathrm{search}}$.

1.

Success case ($\mathcal{T}\left(G\right)\ne \varnothing$):  If the maximum-degree vertex $v_{max}$ participates in at least one triangle, then in the worst case $T_{\mathrm{search}}=\mathcal{O}\left(d_{max}^2\right)$, giving

$$T_{\mathrm{detect}}=\mathcal{O}(nlogn+d_{max}^2).$$

When the local clustering coefficient $C\left(v_{max}\right)>0$, the expected number of neighbor pairs inspected before detection is $\mathcal{O}(1/C\left(v_{max}\right))$, so the expected search time reduces to $\mathcal{O}(d_{max}+1/C\left(v_{max}\right))$.

2.

Failure case ($\mathcal{T}\left(G\right)=\varnothing$):  If no triangle exists, then

$$T_{\mathrm{search}}=\mathcal{O}\left(m\alpha \left(G\right)\right)\subseteq \mathcal{O}\left(m^{3/2}\right),$$

giving $T_{\mathrm{detect}}=\mathcal{O}(nlogn+m^{3/2})$.

Proof. Case 1: Success. Under the Dense Branch (selected when $\delta \ge 0.1$), the first vertex processed is $v_{max}$. The initialization of $\mathrm{Marked}\left[v_{max}\right]$ requires $\mathsf{\Theta }\left(d_{max}\right)$ operations to iterate over $\mathrm{Adj}\left[v_{max}\right]$ and build $N_{v_{max}}^{+}$. The algorithm then checks all distinct pairs $(v,w)\in N_{v_{max}}^{+}\times N_{v_{max}}^{+}$ in order, stopping at the first pair for which $(v,w)\in E$.

In the worst case, all $\left({\displaystyle \genfrac{}{}{0pt}{}{d_{max}}{2}}\right)=\mathcal{O}\left(d_{max}^2\right)$ pairs are checked before the triangle is found (this occurs, for example, when only the last pair of processed neighbors is connected). Hence

$$T_{\mathrm{search}}\le \mathsf{\Theta }\left(d_{max}\right)+\mathcal{O}\left(d_{max}^2\right)=\mathcal{O}\left(d_{max}^2\right).$$

Under the probabilistic assumption that each pair of neighbors of $v_{max}$ is independently connected with probability $C\left(v_{max}\right)$, the number of pairs checked before success follows a geometric distribution with success probability $C\left(v_{max}\right)$, giving an expected count of $1/C\left(v_{max}\right)$. In this case the expected search time is $\mathcal{O}(d_{max}+1/C\left(v_{max}\right))$.

Special case $K_n$: For the complete graph $K_n$ we have $d_{max}=n-1$ and $C\left(v_{max}\right)=1$, so the first pair checked is always a triangle. Thus $T_{\mathrm{search}}=\mathcal{O}\left(n\right)$ and $T_{\mathrm{detect}}=\mathcal{O}(nlogn)$.

Case 2: Failure. If G is triangle-free, no pair $(v,w)\in N_u^{+}\times N_u^{+}$ satisfies $(v,w)\in E$ for any u. The algorithm must exhaust the complete search space. The total number of pair checks across all vertices u is bounded by ${\sum }_{u\in V}{\left|N_u^{+}\right|}^2/2$; this quantity is at most the number of paths of length 2 in G, which is bounded by ${\sum }_{(u,v)\in E}min(d\left(u\right),d\left(v\right))\le 2m\alpha \left(G\right)$ by the Chiba–Nishizeki inequality [3]. Therefore $T_{\mathrm{search}}=\mathcal{O}\left(m\alpha \left(G\right)\right)\subseteq \mathcal{O}\left(m^{3/2}\right)$.    □

Remar 1.

The bound $T_{\mathrm{detect}}=\mathcal{O}(nlogn+m^{3/2})$ in Case 2 is not a linear-time guarantee; it equals the full enumeration bound. The description “near-linear” applies only to graph families with bounded arboricity (e.g., planar graphs, for which $\alpha \left(G\right)=\mathcal{O}\left(1\right)$). For general graphs, $\alpha \left(G\right)\le \sqrt{m}$, so $m\alpha \left(G\right)\le m^{3/2}$.

4. Experimental Evaluation

4.1. Setup

We evaluate Aegypti on complement graphs of the DIMACS maximum-clique benchmark instances [5]. These complement graphs are typically dense and contain many triangles, making them a challenging and well-studied testbed for triangle routines.

Hardware and software.

• Processor: 11th Gen Intel Core i7-1165G7 @ 2.80 GHz
• Memory: 32 GB DDR4 RAM
• Operating System: Windows 10 Home
• Python 3.12.0; aegypti v0.3.7; numpy (matrix multiplication baseline)

Experiments were conducted on March 1–2, 2026 against the benchmarks available at [6].

4.2. Triangle Detection

We compare two algorithms:

• Aegypti: the algorithm presented in this paper, with $\mathrm{first}\_\mathrm{triangle}=\mathrm{True}$.
• Matrix Multiplication (MatMul): a classical approach based on squaring the adjacency matrix; its time complexity is at least $\mathcal{O}\left(m^{1.407}\right)$ [1]. Unlike Aegypti, this baseline only verifies the existence of a triangle (it does not return a specific witness).

Table 1 reports results for a representative selection of instances from each benchmark family. The column “Result” gives the outcome of both algorithms (they always agree). The column “Witness” gives the triangle reported by Aegypti (not available from MatMul). Times are measured in milliseconds; 0.0 indicates resolution below the timer granularity ($<1$ ms).

4.3. Discussion of Detection Results

Across all 78 tested instances, Aegypti and the matrix-multiplication baseline agree on the outcome (triangle found or triangle free). Aegypti reports a concrete witness vertex triple in every positive case, while the MatMul baseline does not. On the majority of instances with $n\le 1,000$, Aegypti terminates in sub-millisecond time (logged as 0.0 ms), while MatMul often requires tens or hundreds of milliseconds on the same inputs. The largest instances tested—C4000.5 ($n=4,000$) and keller6 ($n=3,361$)—provide a stark contrast: Aegypti detects a triangle in 6.01 ms and 6.01 ms respectively, whereas MatMul requires 52.2 s and 8.7 s. The triangle-free instances (hamming6-2, hamming8-2, hamming10-2) are handled correctly by both approaches; on hamming10-2 the times are comparable (4.67 ms vs. 3.03 ms), consistent with the failure-case bound $\mathcal{O}\left(m^{3/2}\right)$ applying to both.

4.4. Triangle Enumeration

Table 2 reports results for the full enumeration of triangles on the same benchmark family, without comparison to any other method (the enumeration variant returns all triangles; the MatMul baseline cannot enumerate triangles).

4.5. Discussion of Enumeration Results

The enumeration results confirm that runtime scales with the output size t, consistent with the $\mathcal{O}(m^{3/2}+t)$ bound. For instances with small triangle counts—such as MANN_a81 (1,080 triangles) and C125.9 (344 triangles)—the algorithm terminates in under 10 ms. For dense instances with millions of triangles—such as p_hat700-1 (24.8 million triangles in 34.2 s) and c-fat500-1 (18.5 million in 20.6 s)—the runtime grows proportionally, as expected from an output-sensitive algorithm.

5. Impact

The Aegypti algorithm is applicable wherever triangle detection or counting is required as a primitive computation:

• Social Network Analysis: Identifying tightly-knit communities through local clustering coefficients and transitivity ratios.
• Bioinformatics: Detecting protein–protein interaction motifs in biological networks [7].
• Web and Graph Mining: Analyzing link structures and network topology in large sparse graphs [8].

6. Conclusions

This paper has formalized Aegypti, a hybrid algorithm for triangle detection and enumeration that combines descending degree ordering with an adaptive selection between a sparse set-intersection branch and a dense forward-marking branch.

For full enumeration, the algorithm achieves the $\mathcal{O}(nlogn+m\alpha \left(G\right)+t)\subseteq \mathcal{O}(nlogn+m^{3/2}+t)$ bound established by the Chiba–Nishizeki framework [3]. For the detection variant, we prove a worst-case bound of $\mathcal{O}(nlogn+d_{max}^2)$ when the maximum-degree vertex participates in a triangle, with the quadratic factor in $d_{max}$ reducing to $\mathcal{O}(d_{max}+1/C\left(v_{max}\right))$ in expectation under a positive local clustering coefficient. When no triangle exists, the failure-case bound matches the enumeration bound: $\mathcal{O}(nlogn+m^{3/2})$.

Experiments on complement graphs of the full DIMACS maximum-clique benchmark suite demonstrate that detection terminates in sub-millisecond time on the large majority of instances, while the matrix-multiplication baseline—which only verifies existence—requires substantially more time on the same inputs. The enumeration experiments confirm output-sensitive scaling consistent with the theoretical bound.

The open-source implementation aegypti (version 0.3.7) provides a verified, practically efficient solution for triangle computation in Python.