Learning to Trace Seiberg Dualities

Core Idea§

Seiberg dualities relate seemingly different supersymmetric quiver gauge theories, manifesting mathematically as quiver mutations. Determining whether two quivers are mutation-equivalent (i.e., dual) is computationally hard. This paper frames duality detection as a binary classification / search problem and trains neural networks (transformers and MLPs) to predict whether two quivers are related via a sequence of mutations.

Mathematical Setup§

A quiver $Q$ is a directed graph with node set $Q_0$ and arrow set $Q_1$. A mutation at node $k$ (denoted $\mu_k$) transforms $Q$ into $\mu_k Q$ via:

$$ \mu_k: (Q_0, Q_1) \mapsto (Q_0', Q_1') $$

where the adjacency matrix $A$ of $Q$ (with $A_{ij}$ arrows from $i$ to $j$) updates as:

$$ A'_{ij} = \begin{cases} -A_{ij}, & \text{if } i=k \text{ or } j=k \\ A_{ij} + |A_{ik}| A_{kj} + A_{ik} |A_{kj}|, & \text{otherwise} \end{cases} $$

Two quivers are Seiberg dual if they lie in the same mutation class. For quivers with $\sim 10$ nodes, the mutation graph is massive, making exhaustive search infeasible.

Method§

Rather than solving the isomorphism problem directly, the authors train neural networks to predict whether two quivers are connected by a path of mutations. They represent each quiver as an adjacency matrix (or as sequences of arrows) and feed pairs into either:

• A transformer encoder with an aggregation token and a binary classification head.
• A multi-layer perceptron (MLP) operating on flattened adjacency matrices.

They also combine the network with a pathfinder algorithm (essentially A* or Dijkstra-like search on the quiver mutation graph) to provide additional heuristic guidance. The pathfinder generates candidate mutation sequences, and the network scores them, enabling a greedy best-first search.

Results§

For quivers with a modest number of nodes ($\approx 10$), both transformers and MLPs surpass deterministic search baselines in terms of speed and accuracy. Augmenting neural predictions with pathfinder algorithms provides a further efficiency boost, effectively giving the network a learned “shortcut heuristic” on an otherwise intractable graph.

Implementation Sketch§

The following PyTorch snippet outlines a simplified transformer-based duality classifier:

import torch
import torch.nn as nn
from torch.nn import TransformerEncoder, TransformerEncoderLayer

class QuiverDualityTransformer(nn.Module):
    def __init__(self, num_nodes=10, d_model=64, nhead=4, num_layers=2):
        super().__init__()
        self.input_proj = nn.Linear(1, d_model)
        encoder_layer = TransformerEncoderLayer(d_model=d_model, nhead=nhead, batch_first=True)
        self.transformer = TransformerEncoder(encoder_layer, num_layers=num_layers)
        self.cls_token = nn.Parameter(torch.randn(1, 1, d_model))
        self.classifier = nn.Sequential(
            nn.Linear(d_model, d_model),
            nn.ReLU(),
            nn.Linear(d_model, 1)
        )

    def forward(self, x1, x2):
        # x1, x2: (batch, num_nodes, num_nodes, 1) adjacency with signs
        b = x1.size(0)
        d = self.input_proj.weight.size(1)
        # Flatten nodes and arrows into token sequence
        f1 = x1.flatten(1, 2)  # (b, n^2, 1)
        f2 = x2.flatten(1, 2)
        tokens = self.input_proj(torch.cat([f1, f2], dim=1))  # (b, 2n^2, d)
        cls = self.cls_token.expand(b, -1, -1)
        tokens = torch.cat([cls, tokens], dim=1)
        out = self.transformer(tokens)
        return self.classifier(out[:, 0])

The model is trained with binary cross-entropy on pairs known to be dual or non-dual, generated by applying random mutation sequences from a seed quiver.

Takeaway§

This work demonstrates that neural networks can learn to navigate non-trivial combinatorial structures in theoretical physics, and that hybrid neural-search approaches can outperform purely deterministic algorithms. The authors suggest this could become a standard benchmark for evaluating frontier AI models on physics-informed tasks.