TriDS: Multi-Domain Systems in Graph Mining & Docking

• TriDS is a label applied to diverse research systems, representing parallel triad census methods in graph mining, immersive 3D triangle visualization, and unified molecular docking workflows.
• In graph mining and visualization, TriDS leverages optimized algorithms and architecture-aware implementations to efficiently analyze triadic structures in large and dense networks.
• In molecular docking, TriDS unifies binding-site prediction, conformational sampling, and scoring into a single differentiable pipeline that achieves robust performance on multiple benchmarks.

Searching arXiv for papers using the term “TriDS” and closely related variants to ground the entry in the literature. TriDS is a non-unique label in the arXiv literature rather than a single standardized framework. It has been used for at least three distinct research systems: a shared-memory parallel triad census system for large directed graphs, a triangle-centric immersive visualization system that extends adjacency matrices into 3D, and an AI-native molecular docking framework that unifies binding-site prediction, conformational sampling, and scoring (Jr. et al., 2012, Pan et al., 2023, Liu et al., 28 Oct 2025). The term therefore requires domain-specific disambiguation before any methodological or empirical claim is interpreted.

1. Scope and disambiguation

The literature applies the label “TriDS” to unrelated technical objects in graph mining, visualization, and computational drug discovery. In one usage, the object of computation is the directed triad census; in another, it is the closed triad or triangle rendered as a first-class visual primitive; in a third, it is a unified docking workflow built around three integrated components—binding Site prediction, Scoring, and Sampling (Jr. et al., 2012, Pan et al., 2023, Liu et al., 28 Oct 2025).

Research area	TriDS denotes	Defining idea
Large-scale graph mining	Parallel triad census system	Shared-memory execution of subquadratic triadic analysis
Social-network visualization	3D adjacency-matrix system	A cube cell encodes a triangle rather than an edge
Molecular docking	Unified docking framework	Binding-site prediction, sampling, and scoring in one differentiable pipeline

This distribution of meanings suggests that “TriDS” functions more as a reusable label than as a stable cross-domain acronym. A plausible implication is that numerical results, design trade-offs, and evaluation protocols associated with one TriDS instance are not transferable to the others without reinterpreting the underlying task.

2. TriDS as a scalable shared-memory triad census system

In large-scale graph mining, TriDS denotes an optimized parallel triad census framework for directed graphs on shared-memory architectures (Jr. et al., 2012). The central object is the triad census: the count of all isomorphism classes of directed 3-node subgraphs. A triad is defined as “a subgraph of three actors and the directed relationships among them.” For a directed graph with $n$ nodes, the total number of possible triads, including null triads, is

$\frac{n(n - 1)(n - 2)}{6}.$

The paper notes that a directed triad has $64$ possible states, reducible to a $16$-element triad census by grouping isomorphic cases. The final count of null triads is obtained by subtracting the non-null counts from the total:

$$\text{Census}[1] = \frac{1}{6}n(n-1)(n-2) - \sum_{i=2}^{16}\text{Census}[i].$$

The algorithmic substrate is the Batagelj and Mrvar subquadratic triad census algorithm, preferred over naïve $O(n^3)$ enumeration and Moody’s $O(n^2)$ matrix-based method because its edge-oriented execution is $O(m)$ on sparse graphs. Its control flow iterates over $u \in V$, then over $v \in N[u]$ subject to $\frac{n(n - 1)(n - 2)}{6}.$0, forms

$\frac{n(n - 1)(n - 2)}{6}.$1

counts dyadic triads using $\frac{n(n - 1)(n - 2)}{6}.$2, and scans candidate third vertices $\frac{n(n - 1)(n - 2)}{6}.$3 under a canonical ordering that suppresses duplicates. For each connected triad $\frac{n(n - 1)(n - 2)}{6}.$4, the implementation calls IsoTricode(u,v,w) to classify the pattern and increment the appropriate census entry. The significance of this design is that the algorithm follows observed edges rather than all node triples.

The system-level contribution lies in making this asymptotic advantage practical on shared memory. The implementation uses a compact representation akin to CSR, with a single edge array and node offsets. The two low bits of each stored edge identifier encode direction: "01" for an edge from the current node to the neighbor, "10" for the reverse direction, and "11" for bidirectional edges. Adjacency lists are sorted, enabling binary search and more cache-friendly traversal. A further optimization avoids materializing $\frac{n(n - 1)(n - 2)}{6}.$5: two pointers traverse the sorted neighbor arrays of $\frac{n(n - 1)(n - 2)}{6}.$6 and $\frac{n(n - 1)(n - 2)}{6}.$7 in situ, advancing together when both lists share a neighbor. This reduces temporary storage and improves locality.

Contention on the census vector is handled by sharding updates across $\frac{n(n - 1)(n - 2)}{6}.$8 local triad census vectors selected by a hash of $\frac{n(n - 1)(n - 2)}{6}.$9 interpreted as a concatenated string. The local vectors are summed at the end. On non-XMT platforms, the parallelization uses OpenMP-style execution, with atomics replacing XMT hardware atomic support. The authors report that they did not rely on data partitioning or prefetching because graph access patterns were too irregular. On Superdome and NUMA systems, the compiler could not collapse an imperfectly nested loop, so a manual “manhatten collapse” was applied; dynamic scheduling was reported as the best schedule, whereas guided scheduling performed poorly.

The evaluation spans three shared-memory architectures: Cray XMT, HP Superdome, and an AMD multi-core NUMA machine. The datasets are the US patents citation graph, the Orkut social graph, and the .uk Webgraph. The results show a pronounced architecture dependence. On the patents graph, the NUMA machine performs best at low core counts, with the XMT and NUMA curves crossing at $64$0 processors. On Orkut, the XMT scales steadily and shows nearly constant parallel efficiency, while the NUMA and Superdome systems degrade at higher thread counts. On the Webgraph, only the XMT can run the largest case at full scale, achieving good linear speedup from $64$1 to $64$2 processors. The paper also reports $64$3–$64$4 CPU utilization on $64$5 processors for Orkut, unusually high for XMT applications. The broader conclusion is that scalable triadic analysis depends not only on asymptotic complexity but also on architecture-aware implementation for irregular memory access, skewed degree distributions, and shared-counter contention.

3. TriDS as a 3D adjacency-matrix system for triangle analysis

In network visualization, TriDS refers to a system that extends adjacency matrices into three dimensions so that a cell encodes a triangle rather than an edge (Pan et al., 2023). The target setting is triangle-rich social networks in which closed triads are important for understanding direct and indirect relationships, influence, community structure, and ego-network organization. The paper formulates three requirements: R1 show all triangles at both coarse and fine granularity, R2 preserve hierarchical distribution of triangles, and R3 provide overall graph context on demand.

The system is motivated by limitations in both node-link diagrams and 2D adjacency matrices. Node-link diagrams suffer from triangle overlap, edge overlap, and hairball clutter in dense graphs. Standard adjacency matrices remove edge crossings but do not represent the third node of a triangle explicitly. TriDS addresses this by introducing a third matrix axis, called a layer. For an undirected graph $64$6, the 3D adjacency matrix $64$7 is defined as

$64$8

with the same node ordering used on all three axes. A cell at $64$9 thus represents the triad formed by $16$0.

Symmetry management is a central design issue. A triangle has $16$1 symmetric permutations, so showing all copies would create substantial redundancy. TriDS therefore displays only the canonical form by default and reveals symmetric copies only when a node is selected. The paper defines a symmetric 3D matrix

$16$2

used for reordering and slice-similarity computation. The cube geometry assigns semantic meaning to spatial placement: triangles sharing the same node lie on the same slice, and triangles sharing the same edge lie on the same straight line.

The reordering method is designed to bring triangles within dense subgraphs close to one another. The $16$3 matrix is treated as $16$4 slices, where slice $16$5 is $16$6. Slice similarity is computed using cosine similarity, and recursion is guided by triangle density

$16$7

where $16$8 is the number of triangles and $16$9 is the number of wedges. The algorithm cut_dense_triangles builds a similarity graph $$\text{Census}[1] = \frac{1}{6}n(n-1)(n-2) - \sum_{i=2}^{16}\text{Census}[i].$$0, collects all positive-similarity slice pairs into a list $$\text{Census}[1] = \frac{1}{6}n(n-1)(n-2) - \sum_{i=2}^{16}\text{Census}[i].$$1, removes edges in ascending order of similarity, stops when $$\text{Census}[1] = \frac{1}{6}n(n-1)(n-2) - \sum_{i=2}^{16}\text{Census}[i].$$2 disconnects, recursively processes each connected component, stops recursion at a threshold $$\text{Census}[1] = \frac{1}{6}n(n-1)(n-2) - \sum_{i=2}^{16}\text{Census}[i].$$3, sorts the resulting dense triangle sets by descending node count, and outputs node indices in that order for all three axes. This is presented as a hierarchical clustering strategy specialized for triangle-rich graphs.

The system is implemented in Unity 3D, with C# for reordering and interaction, Python networkx for force-directed layout, and a Meta Quest 2 headset and controllers for immersive interaction. The visual design combines a 3D cube with a node-link reference view. If cluster information is available, a triangle is assigned to a cluster when two or more of its nodes belong to that cluster; otherwise it is assigned to “Other,” colored gray. Interaction includes controller-based rotation, zoom by physical movement in VR, cell selection with slice expansion, and coordinated highlighting between the cube and the node-link view.

The user study compares NL and NL+Cube with $$\text{Census}[1] = \frac{1}{6}n(n-1)(n-2) - \sum_{i=2}^{16}\text{Census}[i].$$4 participants across three task types: T1 graph-level cluster density comparison, T2 cluster-level node membership, and T3 node-level influence comparison. The training dataset is Karate Club; the evaluation datasets are American Football and EuAll Email. The strongest result is for T2, where accuracy rises from $$\text{Census}[1] = \frac{1}{6}n(n-1)(n-2) - \sum_{i=2}^{16}\text{Census}[i].$$5 in NL to $$\text{Census}[1] = \frac{1}{6}n(n-1)(n-2) - \sum_{i=2}^{16}\text{Census}[i].$$6 in NL+Cube, with $$\text{Census}[1] = \frac{1}{6}n(n-1)(n-2) - \sum_{i=2}^{16}\text{Census}[i].$$7. For T3, accuracy improves from $$\text{Census}[1] = \frac{1}{6}n(n-1)(n-2) - \sum_{i=2}^{16}\text{Census}[i].$$8 to $$\text{Census}[1] = \frac{1}{6}n(n-1)(n-2) - \sum_{i=2}^{16}\text{Census}[i].$$9, with $O(n^3)$0. No statistically significant differences in time are reported, so the interpretation is improved accuracy without a significant time penalty. The paper also notes limitations: controller-based selection may be less intuitive than hand gestures, the sample is small and mostly visualization-experienced, the cube does not encode inter-cluster distance as a force-directed node-link layout does, and the current focus is on static closed triads rather than dynamic evolution or open triads.

4. TriDS as a unified AI-native molecular docking framework

In molecular docking, TriDS denotes a unified framework for Deep learning models for binding Site prediction, Scoring, and Sampling (Liu et al., 28 Oct 2025). The problem formulation emphasizes that many docking pipelines split blind docking into separate stages—binding-site detection, pose generation, and rescoring—and that many deep-learning methods still follow a docking-then-rescoring workflow. TriDS aims to unify these components in a single differentiable pipeline while also addressing the problem that ML-generated poses may be physically implausible.

The workflow has two entry modes. If a reference ligand is available, residues within $O(n^3)$1 Å of the ligand are extracted as the pocket for scoring and sampling. If no reference ligand is available, TriDS invokes a binding-site prediction model with the same architecture and parameters as the earlier DSDP binding-site predictor. Candidate poses are then evaluated by a differentiable ML scoring function, and its gradients with respect to ligand degrees of freedom are used to refine poses during Monte Carlo sampling. The unification lies in the fact that the same learned scoring model both evaluates and guides the search.

The scoring model is TriScore, derived from RTMScore. Its architecture has three parts. First, feature extraction converts protein and ligand into residue- and atom-level graphs; ligand features are built with OpenBabel and PyTorch Geometric, while the protein is represented as a residue-based graph with transformer layers. Second, protein and ligand graph features are concatenated. Third, a Mixed Density Network predicts a probability distribution over shortest distances between protein and ligand node pairs. The scoring equation is

$O(n^3)$2

where $O(n^3)$3 is the distance between protein node $O(n^3)$4 and ligand node $O(n^3)$5, and only pairs with distance shorter than $O(n^3)$6 Å are used at prediction time.

Sampling combines Metropolis Monte Carlo with gradient descent refinement. The loop randomly initializes ligand degrees of freedom, randomly perturbs one degree of freedom, runs gradient-based refinement using the differentiable scoring model, accepts or rejects the proposal using the Metropolis criterion, repeats for multiple loops and multiple copies in parallel, and ranks final poses by score. The Monte Carlo acceptance rule is

$O(n^3)$7

with $O(n^3)$8, chosen so that the acceptance probability is $O(n^3)$9 for a $O(n^2)$0-point change in TriScore. To reduce unphysical overlaps, the method adds an analytic repulsion term with $O(n^2)$1 and $O(n^2)$2 Å. Training uses PDBbind-v2020 with Adam, batch size $O(n^2)$3, learning rate $O(n^2)$4, weight decay $O(n^2)$5, and early stopping if the validation loss does not improve for $O(n^2)$6 epochs.

The empirical study uses PDBbind-v2020 time-split, CASF-2016, PoseBusters, and DEKOIS 2.0. The reported metrics include docking success rate (best-scored pose RMSD $O(n^2)$7 Å), median RMSD, PoseBusters physical validity, AUROC, EF0.5\%, EF1\%, and CASF forward and reverse screening success rates. On the PDBbind time-split benchmark, TriDS reports $O(n^2)$8 success rate, $O(n^2)$9 Å median RMSD, and $O(m)$0 of poses that are both successful and PoseBusters-valid. On PoseBusters redocking it reports $O(m)$1 success rate and $O(m)$2 after physical validation. On CASF-2016 it reports docking $O(m)$3, forward EF1\% $O(m)$4, forward SR1\% $O(m)$5, and reverse $O(m)$6. On DEKOIS 2.0 it reports ROC-AUC $O(m)$7, EF0.5\% $O(m)$8, and EF1\% $O(m)$9. The paper also highlights relative robustness on ligands above $u \in V$0 Da and shows that Adam outperforms AdamW, RMSprop, AdaGrad, and SGD for the refinement step.

The implementation is designed for practical use. It is written in PyTorch C++ / LibTorch with CUDA, supports multiple file formats via OpenBabel, including sdf, mol2, SMILES, pdb, and pdbqt, provides a Python API, and allows users to plug in their own ML-based scoring function. Rotatable bonds and their rotated subgroups are represented as masks for efficient coordinate updates. Heavy use of CUDA streams is reported, with $u \in V$1 streams and depth $u \in V$2 in the sampling setup, and an optimized default of streams $u \in V$3 and depth $u \in V$4. Runtime is reported as $u \in V$5 s per ligand on an RTX A6000, or $u \in V$6 s in batch mode, with GPU memory around $u \in V$7 MB.

5. Related and easily confused literature

A substantial body of triangle- and triad-centered work is adjacent to TriDS without using the same system name. In distributed algorithms, “Tri, Tri again”: Finding Triangles and Small Subgraphs in a Distributed Setting studies triangle and small-subgraph detection in a CONGEST-style clique model with $u \in V$8-bit messages (Dolev et al., 2012). Its results include a deterministic $u \in V$9-vertex subgraph test in $v \in N[u]$0 rounds, the triangle-specific TriPartition method in $v \in N[u]$1 rounds, the randomized TriSample bound $v \in N[u]$2 in expectation, and sparse-graph bounds $v \in N[u]$3 and $v \in N[u]$4. This literature is methodologically close to the graph-analytic TriDS usage because it also treats triangles as primary algorithmic objects, but it addresses a different computational model.

In formal semantics and logic, “Ludics without Designs I: Triads” introduces the notion of a triad as an ordered triple $v \in N[u]$5 consisting of positive terms, negative terms, and an orthogonality relation $v \in N[u]$6 (Basaldella, 2015). The paper develops orthogonal sets, closed sets, specialization, semantical consequence, entailment systems, continuous functionals, and regular functionals. This is unrelated to either graph-analytic or docking uses of TriDS; the commonality is the word “triad,” not a shared software or systems lineage.

Bibliographic confusion also arises from superficially relevant but substantively irrelevant records. One listed candidate, “An Optimized Tri-store System for Multi-model Data Analytics,” is described in the provided source as an IEEEtran class example with placeholder sections rather than a substantive paper on tri-stores, polystores, or any TriDS-related system (Zheng et al., 2023). The practical consequence is that arXiv metadata and topic keywords alone are insufficient for disambiguation.

6. Comparative interpretation

Across its distinct uses, TriDS consistently elevates a three-way structure to first-class status, but the nature of that structure changes by field. In shared-memory graph mining, the object is the triad census over directed 3-node motifs (Jr. et al., 2012). In immersive visualization, the object is the closed triad or triangle, encoded directly as a volumetric matrix cell (Pan et al., 2023). In docking, the three-way structure is a workflow integration of binding-site prediction, scoring, and sampling, implemented through a differentiable learned objective that guides search (Liu et al., 28 Oct 2025).

This suggests a common design philosophy despite the absence of a unified research program: higher-order structure is treated as native rather than derived. The graph system avoids reducing triadic analysis to generic edge processing; the visualization system avoids reducing triangle perception to pairwise edge inspection; the docking framework avoids separating scoring from conformational exploration. A plausible implication is that the label “TriDS” tends to be attached to frameworks that collapse a latent three-part dependency into a primary representational or optimization unit.

The evaluation regimes also differ sharply. The graph-mining TriDS is assessed through architecture-sensitive scalability, memory behavior, and processor-count crossovers. The visualization TriDS is assessed through accuracy and time in human analytic tasks, with significance testing over controlled conditions. The docking TriDS is assessed through benchmark success rates, RMSD, virtual-screening enrichment, physical validity, runtime, and GPU memory. These are not competing instantiations of one method family; they are separate domain solutions that happen to share a name.