{
 "artifacts": null,
 "category": "architecture",
 "description": "Give every possible pairwise relation its own recurrent latent state, stored in a dictionary keyed by stable node identities, instead of discarding the state whenever the edge is absent from the current graph. At each timestep, active edges retrieve their old state, update it with the current pair features and neighborhood messages, and write it back after message passing. This should improve predictions in dynamic graphs with intermittent interactions and reduce the burden on node states to remember which specific neighbor caused an earlier event.",
 "formulas_latex": [
  "$$\\mathcal{E}^{t}=\\left\\{(i,j):\\left\\|\\mathbf{x}_{i}^{t}-\\mathbf{x}_{j}^{t}\\right\\|_{2}\u003c\\alpha\\left(r_{i}+r_{j}\\right),\\ i\u003cj\\right\\}$$",
  "$$a_{ij}^{t}=\\sum_{k\\in\\mathcal{N}(i,j,t)}\\operatorname{softmax}_{k}\\!\\left(\\frac{(W_Qe_{ij}^{t})^{\\mathsf T}(W_Ke_{ik}^{t})}{\\sqrt d}\\right)W_Ve_{ik}^{t}$$",
  "$$z=\\sigma(W_z u+U_zm+b_z),\\quad q=\\sigma(W_q u+U_qm+b_q),\\quad \\widetilde m=\\tanh(W_m u+U_m(q\\odot m)+b_m),\\quad m^{+}=(1-z)\\odot m+z\\odot\\widetilde m$$",
  "$$m_{ij}^{t+1}=\\begin{cases}\\operatorname{GRU}\\!\\left(m_{ij}^{t},[e_{ij}^{t};a_{ij}^{t}]\\right),\u0026(i,j)\\in\\mathcal{E}^{t},\\\\m_{ij}^{t},\u0026(i,j)\\notin\\mathcal{E}^{t}\\text{ and retained in the dictionary}.\\end{cases}$$"
 ],
 "id": 3117,
 "implementation": "(1) Integration point: modify a temporal GNN or graph-transformer layer that currently recomputes edge embeddings from the active adjacency at every timestep. Assume each node has a stable integer ID and each timestep provides node features x[t] and a candidate-edge generator. Build the active edge set using the paper's rule when geometric positions and radii exist; otherwise use a task-specific threshold, k-nearest-neighbor graph, or observed event list. Maintain a GPU hash map memory[(min(i,j),max(i,j))] containing a vector of dimension d_mem and optionally a last_seen timestep.\n\n(2) Pseudocode:\n```text\nmemory = empty_map()\nfor t in range(T):\n    E = {(i,j): distance(x[i],x[j]) \u003c alpha*(r[i]+r[j])}\n    for (i,j) in E:\n        m = memory.get((i,j), learned_zero)\n        e = edge_encoder(x[i], x[j], edge_attributes[i,j])\n        a = edge_attention(e, neighboring_active_edges(i,j), node_states)\n        u = concat(e, a)\n        z = sigmoid(Wz@u + Uz@m + bz)\n        q = sigmoid(Wq@u + Uq@m + bq)\n        candidate = tanh(Wm@u + Um@(q*m) + bm)\n        m_new = (1-z)*m + z*candidate\n        memory[(i,j)] = m_new\n        edge_embedding[i,j] = concat(e, m_new)\n    node_states = graph_message_passing(node_states, edge_embedding, E)\n    prediction[t] = decoder(node_states, edge_embedding)\n```\nUse detached memory between training chunks only if memory growth causes backpropagation-through-time to exceed the budget; otherwise backpropagate for 8-32 steps. Retain inactive memories for a fixed horizon H, or evict them with an LRU policy after H steps. The attention formula above can be replaced with ordinary local edge aggregation for the first MVP.\n\n(3) Computed from the paper's mathematics: dynamic edge construction, stable pair-key lookup, and the gated recurrence. Estimated empirically: the memory dimension d_mem, retention horizon H, attention neighborhood, and whether inactive memories should decay. Add an optional decay $m\\leftarrow\\rho^{\\Delta t}m$ on retrieval, with learned or tuned $\\rho\\in(0,1]$, to prevent stale information.\n\n(4) First cheap experiment: use a synthetic 2D multi-agent interaction dataset with 32 particles whose pair interactions switch on when distance is below a threshold, and train a 2-layer message-passing network to predict positions 10-50 steps ahead. Compare (a) no temporal memory, (b) node GRU memory, and (c) persistent edge GRU memory with identical hidden size and FLOPs. Report one-step MSE, 50-step rollout MSE, error immediately after a previously seen edge reappears, and memory/latency overhead. The hypothesis is specifically lower reactivation error and more stable long rollouts for (c), not necessarily lower one-step error. A successful signal is at least 20% lower long-horizon MSE at equal parameter count, with less than 30% inference overhead.",
 "math_summary": "The paper constructs the active graph at time t as $\\mathcal{G}^{t}=(\\mathcal{V},\\mathcal{E}^{t})$, with nodes representing particles and $\\mathcal{E}^{t}=\\{(i,j):\\|\\mathbf{x}_{i}^{t}-\\mathbf{x}_{j}^{t}\\|_{2}\u003c\\alpha(r_i+r_j),\\ i\u003cj\\}$. Here $\\mathbf{x}_i^t$ is the feature or position of node i at time t, $r_i$ is its radius or entity scale, and $\\alpha$ is a skin factor controlling when an edge becomes active. The transferable operation is not the granular radius criterion itself, but the separation between a changing active edge set and a persistent state indexed by the stable pair key $(i,j)$. For each active edge, let $m_{ij}^t$ be its stored memory, $e_{ij}^t$ its current pair feature, and $a_{ij}^t$ its aggregated attention/message input. Use a gated recurrent update $m_{ij}^{t+1}=\\operatorname{GRU}(m_{ij}^{t},[e_{ij}^{t};a_{ij}^{t}])$. A concrete GRU expansion is $z=\\sigma(W_z u+U_zm+b_z)$, $q=\\sigma(W_q u+U_qm+b_q)$, $\\tilde m=\\tanh(W_m u+U_m(q\\odot m)+b_m)$, and $m^+= (1-z)\\odot m+z\\odot\\tilde m$, where $u=[e_{ij}^{t};a_{ij}^{t}]$, $\\sigma$ is the sigmoid, and all W,U,b are learned parameters. The dictionary preserves $m_{ij}$ across inactive periods; a new pair receives $m_{ij}=0$ or a learned initialization.",
 "math_tags": [
  "graph-theory",
  "dynamical-systems",
  "linear-algebra"
 ],
 "ml_areas": [
  "graph-nn",
  "attention",
  "memory"
 ],
 "paper": {
  "arxiv_id": "2609.02991",
  "arxiv_url": "https://arxiv.org/abs/2609.02991",
  "summary_what_math_gives_to_ml": "The paper's transferable construction is to attach recurrent state to relations rather than to nodes, while rebuilding the active graph from the current geometry. An edge-keyed dictionary lets a relation recover its previous state when it disappears and later reappears, preserving interaction history across changing neighborhoods. This can be generalized to temporal graph networks, multi-agent models, event-based recommendation, and systems where pairwise relationships are intermittent. The most direct experiment is to replace node-only memory in a dynamic graph predictor with persistent edge memory and test long-horizon forecasting under repeated edge formation and deletion.",
  "title": "TRACE: Spatiotemporal Contact Memory Graph Network Simulator for Granular Dynamics",
  "year": "2026"
 },
 "ratings": {
  "difficulty": 5,
  "novelty": 6,
  "usefulness": 7
 },
 "solves": [
  "accuracy",
  "stability"
 ],
 "title": "Persistent Relational Memory",
 "url": "https://synthcore.org/idea/3117/persistent-relational-memory",
 "verification": {
  "peer_reviewed": false,
  "status": "unverified",
  "status_label": "Unverified",
  "verdict_source": "deterministic test code (paired-seed permutation statistics)",
  "verification_axes": {
   "benchmark_mechanism": {
    "confirmed": null,
    "tested": false
   },
   "practical_benchmark": {
    "beats_baseline": null,
    "tested": false
   },
   "toy_mechanism_gate": {
    "confirmed": null,
    "tested": false
   }
  }
 }
}