Deterministic Experience-Memory Graph Edit-Path Subsystem: Architecture and .NET Implementation

Full report

On this page

The evolution of autonomous software agents has demonstrated profound capabilities in decision-making, sequential reasoning, and complex task execution. However, in long-horizon environments, these agents remain highly susceptible to compounding errors and catastrophic failure loops. Historically, self-correction mechanisms have relied heavily on prompt-based online reflection, where a Large Language Model (LLM) iteratively analyzes a failed trajectory, deduces the root cause, and attempts a subsequent trial-and-error execution1. This paradigm is inherently brittle, consumes substantial computational resources, incurs significant API latency, and frequently yields task-specific corrections that fail to generalize2. To overcome the latency and unreliability of iterative online reflection, the Experience Memory Graph (EMG) framework reformulates agent failure recovery as a deterministic graph matching and alignment problem1. By processing experiences offline, the architecture converts historical exploration trajectories (failures) and expert trajectories (successes) into directed Action Decision Graphs (ADGs)4. Aligning these graphs mathematically allows the system to extract a reusable common subgraph of correct behavior and emit a definitive sequence of edit operations that directly transforms a flawed agent workflow into a successful one1. This report provides an exhaustive architectural design and a production-ready .NET implementation for the deterministic graph edit-path subsystem. It delineates the mathematical foundations of graph alignment utilizing Fused Gromov-Wasserstein (FGW) optimal transport, establishes a strictly compliant Domain-Driven Design (DDD) model in C\#, and enforces rigorous canonical serialization protocols to guarantee deterministic execution across distributed environments.

Action Decision Graph Formulation

To escape the limitations of linear trajectory analysis, agent execution histories must be projected into a topological structure that captures state-action dependencies and cyclical behaviors. The Action Decision Graph represents a directed, cyclic schema where actions are treated as vertices, and the environmental observations bridging those actions serve as directed edges2.

Structural Semantics and Failure Loop Mitigation

An agent trajectory inherently consists of a chronologically ordered sequence of observations, environmental states, actions, action results, and terminal outcomes. Translating this linear array into a directed Action Decision Graph necessitates strict normalization and deduplication logic2. When formulating the graph, identical normalized actions—even if reached through divergent observation pathways—must reuse the exact same node representation. This topological folding exposes the underlying decision logic of the agent, highlighting convergence points in a workflow4. However, this poses a distinct challenge when autonomous agents enter failure loops, repeatedly issuing an invalid action upon encountering the same insurmountable observation. Mapping this naively results in parallel edges or an infinitely deep graph chain that destabilizes alignment algorithms and wastes memory4. To preserve topological brevity while retaining failure metrics, the subsystem collapses consecutive invalid actions into a singular structural edge containing execution metadata. By introducing an attempt-counter or a discrete failure-occurrence structure on the edge itself, the graph captures the severity of the failure without bloating the adjacency matrix4.

Optimal Transport and Graph Alignment

The comparison of a failed Action Decision Graph against a successful expert graph to extract corrective paths is a computationally demanding variation of the Graph Edit Distance (GED) problem8. GED seeks the minimal cost path of node and edge additions, deletions, and relabelings required to achieve graph isomorphism9. Due to the NP-hard nature of exact GED computation, the subsystem utilizes an advanced optimal transport relaxation, specifically the Fused Gromov-Wasserstein (FGW) distance11.

The Fused Gromov-Wasserstein Framework

The FGW framework provides a mathematically rigorous mechanism to compare structured objects by simultaneously penalizing feature mismatch and the distortion of intra-object structural relations14. In the context of Action Decision Graphs, the feature mismatch correlates to the semantic distance between normalized agent actions, while the structural distortion correlates to the divergence in environmental observations (edges) connecting those actions17. The subsystem defines the FGW objective to find a probabilistic coupling matrix [Figure omitted from source export] that minimizes the following continuous cost function: [Figure omitted from source export] The components of this objective function operate as follows:

• [Figure omitted from source export] (Feature Cost Matrix): Represents the dissimilarity between action nodes in the source graph and target graph.
• [Figure omitted from source export] (Structural Adjacency Matrices): Encode the weighted observation transitions between actions in their respective graphs.
• [Figure omitted from source export] (Fusion Parameter): Interpolates the emphasis between aligning action features ([Figure omitted from source export]) and aligning graph topology ([Figure omitted from source export])17.
• [Figure omitted from source export] (Transport Plan): The soft-assignment matrix mapping nodes from the failed trajectory to the expert trajectory4.

Accommodating Unbalanced Agent Trajectories

A primary limitation of classical optimal transport, including standard FGW, is the strict requirement for mass conservation—the assumption that the source and target distributions are equal21. Failed agent trajectories are frequently significantly longer or shorter than expert trajectories, resulting in Action Decision Graphs with disparate node counts23. To accommodate this, the subsystem employs Fused Partial Gromov-Wasserstein (FPGW) or Fused Unbalanced Gromov-Wasserstein (FUGW) alignment19. By relaxing the strict marginal constraints through Total Variation (TV) penalties or Kullback-Leibler (KL) divergence regularizers, the solver permits the destruction or creation of mass26. This directly translates to the identification of extraneous actions that must be deleted, or missing actions that must be added, yielding a mathematically sound basis for the DeleteNodeOperation and AddNodeOperation commands.

Algorithmic Optimization and Edit Path Extraction

The continuous relaxation of the alignment problem results in a non-convex quadratic programming objective, typically solved via the Frank-Wolfe algorithm (conditional gradient method)29. The Frank-Wolfe solver iteratively approximates the objective function with a linear surrogate and solves a linear assignment subproblem in each step, rapidly converging to an optimal soft assignment31. Following the convergence of the Frank-Wolfe solver, the continuous transportation plan [Figure omitted from source export] must be discretized to extract a deterministic Graph Edit Plan. The extraction algorithm partitions the alignment into two primary structures1:

1. Common Subgraph: Action nodes and observation edges that achieve a high-confidence mapping with identical feature spaces constitute the correct, reusable workflow. These elements are preserved.

2. Graph Edit Path:

• Source nodes with no valid target mapping dictate a DeleteNodeOperation.
• Target nodes with no valid source mapping dictate an AddNodeOperation.
• Nodes mapped to each other but exhibiting differing action parameters necessitate a RelabelNodeOperation4.
• Similar logical rules dictate the creation of AddEdgeOperation and DeleteEdgeOperation for mismatched observations.

To ensure deterministic testing and continuous integration without invoking heavy continuous solvers, the architecture abstracts the alignment layer, allowing a combinatorial test double (such as the Hungarian algorithm) to substitute the FGW solver in controlled environments34.

Canonical Serialization and Determinism

For the optimal transport solvers and discrete graph matchers to function deterministically, the Action Decision Graphs must exhibit strict value equality37. Autonomous agents frequently emit JSON payloads where property ordering, casing, and schema details fluctuate. Comparing these graphs requires a rigid normalization pipeline ensuring that identical agent behaviors hash to identical canonical values39. The System.Text.Json namespace provides a high-performance framework for handling serialization. However, its default behavior relies on reflection, which returns properties in the metadata declaration order dictated by the assembly—a factor that can vary based on the compiler and runtime environment prior to .NET 739. The subsystem enforces determinism through the application of specific normalization rules outlined below.

Domain-Driven Design: C# Aggregates and Implementations

The implementation relies heavily on C\# record types, which inherently provide structural value equality, immutability, and concise synthesis of GetHashCode() and Equals() methods37. This ensures that node and edge comparisons during graph construction natively evaluate the inner properties rather than reference locations. The architecture strictly adheres to Domain-Driven Design (DDD) principles. The AgentTrajectory and ActionDecisionGraph serve as isolated aggregate roots. Graph edit operations are modeled polymorphically to support extensible instruction sets for the downstream command-processing layer. Furthermore, every public property conforms to the requirement of utilizing the \[Display\] attribute with suffixes omitted, and non-trivial methods contain exhaustive XML documentation.

Agent Trajectory and Normalization Foundations

The following module defines the raw sequential execution history and the normalized representations of actions and observations.

C\# using System; using System.Collections.Generic; using System.ComponentModel.DataAnnotations; using System.Linq;

namespace ExperienceMemoryGraph.Domain.Models { /// \<summary\> /// Represents an immutable, normalized action taken by the agent. /// Structural value equality guarantees that semantically identical actions /// will map to the same mathematical node during graph alignment. /// \</summary\> public record NormalizedAction { \[Display(Name \= "Action Type")\] public string ActionType { get; init; } \= string.Empty;

\[Display(Name \= "Target Object")\] public string TargetObject { get; init; } \= string.Empty;

\[Display(Name \= "Destination")\] public string Destination { get; init; } \= string.Empty;

\[Display(Name \= "Tool")\] public string Tool { get; init; } \= string.Empty;

\[Display(Name \= "Arguments")\] public IReadOnlyDictionary\<string, string\> Arguments { get; init; } \= new Dictionary\<string, string\>();

/// \<summary\> /// Computes a deterministic hash based on lexicographically sorted properties and arguments. /// This ensures invariant node identity across differently ordered serializations. /// \</summary\> /// \<returns\>A deterministic string hash uniquely representing the normalized action.\</returns\> public string ComputeCanonicalHash() { var orderedArgs \= string.Join("|", Arguments.OrderBy(kvp \=\> kvp.Key, StringComparer.Ordinal) .Select(kvp \=\> $"{kvp.Key}:{kvp.Value}"));

return $"{ActionType.ToLowerInvariant()}|{TargetObject.ToLowerInvariant()}|{Destination.ToLowerInvariant()}|{Tool.ToLowerInvariant()}|{orderedArgs}"; } }

/// \<summary\> /// Represents the normalized environmental state or observation preceding an action. /// Provides custom equality operators to mitigate floating-point drift. /// \</summary\> public record NormalizedObservation { \[Display(Name \= "Observation State")\] public string ObservationState { get; init; } \= string.Empty;

\[Display(Name \= "Is Terminal")\] public bool IsTerminal { get; init; }

\[Display(Name \= "Reward")\] public decimal Reward { get; init; }

/// \<summary\> /// Determines if two observations are conceptually identical by executing a /// case-insensitive state comparison and clamping numeric precision. /// \</summary\> /// \<param name="other"\>The comparative observation record.\</param\> /// \<returns\>True if the observations share identical states and clamped rewards; otherwise, false.\</returns\> public virtual bool Equals(NormalizedObservation? other) { if (other is null) return false; return string.Equals(ObservationState, other.ObservationState, StringComparison.OrdinalIgnoreCase) && IsTerminal \== other.IsTerminal && Math.Round(Reward, 4) \== Math.Round(other.Reward, 4); }

/// \<summary\> /// Generates a hash code strictly derived from the normalized properties. /// \</summary\> /// \<returns\>A signed 32-bit integer hash code.\</returns\> public override int GetHashCode() \=\> HashCode.Combine(ObservationState.ToLowerInvariant(), IsTerminal, Math.Round(Reward, 4)); }

/// \<summary\> /// Represents a single discrete step in an agent's linear execution history. /// \</summary\> public record TrajectoryStep { \[Display(Name \= "Step")\] public Guid StepId { get; init; } \= Guid.NewGuid();

\[Display(Name \= "Observation")\] public NormalizedObservation Observation { get; init; } \= new();

\[Display(Name \= "Action")\] public NormalizedAction Action { get; init; } \= new();

\[Display(Name \= "Action Result")\] public string ActionResult { get; init; } \= string.Empty; }

/// \<summary\> /// The aggregate root containing the sequential chronological history of an agent's execution. /// \</summary\> public record AgentTrajectory { \[Display(Name \= "Trajectory")\] public Guid TrajectoryId { get; init; } \= Guid.NewGuid();

\[Display(Name \= "Task Query")\] public string TaskQuery { get; init; } \= string.Empty;

\[Display(Name \= "Is Successful")\] public bool IsSuccessful { get; init; }

\[Display(Name \= "Steps")\] public IReadOnlyList\<TrajectoryStep\> Steps { get; init; } \= Array.Empty\<TrajectoryStep\>(); } }

Action Decision Graph Implementation

The graph models encapsulate the structural folding logic required to transition from a linear sequence to a directed topological structure, applying the failure-loop compression mechanics natively during construction.

C\# using System; using System.Collections.Generic; using System.ComponentModel.DataAnnotations; using System.Linq;

namespace ExperienceMemoryGraph.Domain.Models { /// \<summary\> /// A vertex within the Action Decision Graph, representing a unique normalized action. /// \</summary\> public record ActionDecisionNode { \[Display(Name \= "Node")\] public Guid NodeId { get; init; } \= Guid.NewGuid();

\[Display(Name \= "Action")\] public NormalizedAction Action { get; init; } \= new();

/// \<summary\> /// Overrides equality to strictly bind node identity to the canonical hash of its underlying action. /// \</summary\> /// \<param name="other"\>The comparative node.\</param\> /// \<returns\>True if both nodes represent identical normalized actions.\</returns\> public virtual bool Equals(ActionDecisionNode? other) { if (other is null) return false; return NodeId \== other.NodeId || Action.ComputeCanonicalHash() \== other.Action.ComputeCanonicalHash(); }

/// \<summary\> /// Generates a hash code bound to the canonical action hash. /// \</summary\> /// \<returns\>A signed 32-bit integer hash code.\</returns\> public override int GetHashCode() \=\> Action.ComputeCanonicalHash().GetHashCode(); }

/// \<summary\> /// A directed edge within the Action Decision Graph, representing the environmental state /// transition that triggered the target action. Incorporates metadata for failure compression. /// \</summary\> public record ActionDecisionEdge { \[Display(Name \= "Edge")\] public Guid EdgeId { get; init; } \= Guid.NewGuid();

\[Display(Name \= "Source Node")\] public Guid SourceNodeId { get; init; }

\[Display(Name \= "Target Node")\] public Guid TargetNodeId { get; init; }

\[Display(Name \= "Observation")\] public NormalizedObservation Observation { get; init; } \= new();

\[Display(Name \= "Execution Attempts")\] public int ExecutionAttempts { get; init; } \= 1;

/// \<summary\> /// Generates a mutated edge record reflecting repeated identical failures, /// preserving topological integrity without generating parallel edges. /// \</summary\> /// \<param name="additionalAttempts"\>The quantity of subsequent failures to record.\</param\> /// \<returns\>A new ActionDecisionEdge instance with an incremented attempt counter.\</returns\> public ActionDecisionEdge IncrementFailures(int additionalAttempts \= 1) { return this with { ExecutionAttempts \= this.ExecutionAttempts \+ additionalAttempts }; } }

/// \<summary\> /// The mathematical representation of an agent's workflow trajectory as a directed graph. /// Serves as the primary aggregate root for the optimal transport solvers. /// \</summary\> public record ActionDecisionGraph { \[Display(Name \= "Graph")\] public Guid GraphId { get; init; } \= Guid.NewGuid();

\[Display(Name \= "Nodes")\] public IReadOnlyCollection\<ActionDecisionNode\> Nodes { get; init; } \= new HashSet\<ActionDecisionNode\>();

\[Display(Name \= "Edges")\] public IReadOnlyCollection\<ActionDecisionEdge\> Edges { get; init; } \= new HashSet\<ActionDecisionEdge\>();

/// \<summary\> /// Constructs a directed Action Decision Graph from a sequential Agent Trajectory. /// Analyzes consecutive steps, merges identical actions into singular nodes, and /// collapses sequential failure loops into edge attempt metadata. /// \</summary\> /// \<param name="trajectory"\>The raw trajectory to parse and structurally fold.\</param\> /// \<returns\>A compacted, deterministic ActionDecisionGraph.\</returns\> /// \<exception cref="ArgumentNullException"\>Thrown when the provided trajectory is null.\</exception\> public static ActionDecisionGraph FromTrajectory(AgentTrajectory trajectory) { if (trajectory \== null) throw new ArgumentNullException(nameof(trajectory));

var nodes \= new Dictionary\<string, ActionDecisionNode\>(); var edges \= new List\<ActionDecisionEdge\>();

ActionDecisionNode? previousNode \= null;

foreach (var step in trajectory.Steps) { var actionHash \= step.Action.ComputeCanonicalHash();

if (\!nodes.TryGetValue(actionHash, out var currentNode)) { currentNode \= new ActionDecisionNode { Action \= step.Action }; nodes\[actionHash\] \= currentNode; }

if (previousNode \!= null) { var existingEdge \= edges.FirstOrDefault(e \=\> e.SourceNodeId \== previousNode.NodeId && e.TargetNodeId \== currentNode.NodeId && e.Observation.Equals(step.Observation));

if (existingEdge \!= null) { var updatedEdge \= existingEdge.IncrementFailures(); edges.Remove(existingEdge); edges.Add(updatedEdge); } else { edges.Add(new ActionDecisionEdge { SourceNodeId \= previousNode.NodeId, TargetNodeId \= currentNode.NodeId, Observation \= step.Observation }); } }

previousNode \= currentNode; }

return new ActionDecisionGraph { Nodes \= nodes.Values.ToList(), Edges \= edges }; } } }

Graph Edit Operations and Alignment Results

The optimal transport solver evaluates the graphs and translates the mathematical alignment into discrete edit instructions. These are modeled utilizing polymorphic hierarchy in C\# 11+ to facilitate extensible serialization and downstream processing without reliance on dynamic interpretation.

C\# using System; using System.Collections.Generic; using System.ComponentModel.DataAnnotations; using System.Text.Json.Serialization;

namespace ExperienceMemoryGraph.Domain.Models { /// \<summary\> /// A polymorphic abstraction defining discrete structural mutations derived /// from the Fused Gromov-Wasserstein alignment mapping. /// \</summary\> \[JsonPolymorphic(TypeDiscriminatorPropertyName \= "$type")\] \[JsonDerivedType(typeof(AddNodeOperation), "AddNode")\] \[JsonDerivedType(typeof(DeleteNodeOperation), "DeleteNode")\] \[JsonDerivedType(typeof(RelabelNodeOperation), "RelabelNode")\] \[JsonDerivedType(typeof(AddEdgeOperation), "AddEdge")\] \[JsonDerivedType(typeof(DeleteEdgeOperation), "DeleteEdge")\] public abstract record GraphEditOperation { \[Display(Name \= "Operation")\] public Guid OperationId { get; init; } \= Guid.NewGuid(); }

public record AddNodeOperation : GraphEditOperation { \[Display(Name \= "Node")\] public ActionDecisionNode Node { get; init; } \= new(); }

public record DeleteNodeOperation : GraphEditOperation { \[Display(Name \= "Target Node")\] public Guid TargetNodeId { get; init; } }

public record RelabelNodeOperation : GraphEditOperation { \[Display(Name \= "Target Node")\] public Guid TargetNodeId { get; init; }

\[Display(Name \= "New Action")\] public NormalizedAction NewAction { get; init; } \= new(); }

public record AddEdgeOperation : GraphEditOperation { \[Display(Name \= "Edge")\] public ActionDecisionEdge Edge { get; init; } \= new(); }

public record DeleteEdgeOperation : GraphEditOperation { \[Display(Name \= "Target Edge")\] public Guid TargetEdgeId { get; init; } }

/// \<summary\> /// Represents the deterministic, ordered sequence of operations necessary to convert /// a failed agent workflow graph into a successful workflow graph. /// \</summary\> public record GraphEditPlan { \[Display(Name \= "Plan")\] public Guid PlanId { get; init; } \= Guid.NewGuid();

\[Display(Name \= "Operations")\] public IReadOnlyList\<GraphEditOperation\> Operations { get; init; } \= Array.Empty\<GraphEditOperation\>();

\[Display(Name \= "Total Cost")\] public decimal TotalCost { get; init; } }

/// \<summary\> /// The aggregate result emitted by the optimal transport solver, synthesizing the reusable /// common subgraph topology and the necessary correction path. /// \</summary\> public record GraphAlignmentResult { \[Display(Name \= "Alignment Result")\] public Guid AlignmentResultId { get; init; } \= Guid.NewGuid();

\[Display(Name \= "Common Subgraph")\] public ActionDecisionGraph CommonSubgraph { get; init; } \= new();

\[Display(Name \= "Edit Plan")\] public GraphEditPlan EditPlan { get; init; } \= new();

\[Display(Name \= "Solver Metric")\] public decimal SolverMetric { get; init; } } }

Abstracting the Optimization Solver

The core domain model must remain isolated from the heavy mathematical dependencies required to compute optimal transport or bipartite matching. The architecture achieves this through an abstraction boundary, exposing a clean interface for the command-processing layer. This allows the system to swap a Python-based Frank-Wolfe solver binding with a native C\# combinatorial fallback (e.g., Hungarian algorithm permutations) during constrained environment testing30.

C\# namespace ExperienceMemoryGraph.Domain.Services { /// \<summary\> /// Provides deterministic graph matching and optimal transport alignment abstractions. /// \</summary\> public interface IGraphAlignmentSolver { /// \<summary\> /// Solves the structural and feature mapping between a flawed graph and an expert graph. /// Identifies the reusable common topology and extracts the discrete edit operations. /// \</summary\> /// \<param name="failedGraph"\>The source Action Decision Graph containing structural errors.\</param\> /// \<param name="successfulGraph"\>The target Action Decision Graph representing the validated workflow.\</param\> /// \<returns\>A deterministic GraphAlignmentResult excluding LLM interventions.\</returns\> /// \<exception cref="InvalidOperationException"\>Thrown if graphs possess no overlapping manifold or cannot be mapped.\</exception\> GraphAlignmentResult AlignGraphs(ActionDecisionGraph failedGraph, ActionDecisionGraph successfulGraph); } }

Architectural Implications and Future Outlook

The transition from online LLM-based reflection to offline deterministic graph matching represents a fundamental maturity shift in autonomous agent design. By generating explicit, discrete instructional edits (RelabelNodeOperation, AddEdgeOperation), the subsystem eliminates the latency of prompt generation during critical execution phases1. When an agent re-encounters a specific environmental state, the memory graph deterministically routes the agent to the corrected action, enforcing a loop-free execution path2. Furthermore, mitigating Graph Isomorphism NP-hardness by constraining the domain to sparse Action Decision Graphs and resolving alignment via Unbalanced Gromov-Wasserstein permits the architecture to scale efficiently8. The strict enforcement of Domain-Driven Design principles, coupled with rigorous canonical serialization strategies utilizing .NET’s modern System.Text.Json features, ensures that data drift is eradicated at the architectural level37. As agent systems increasingly demand auditable, testable, and highly resilient memory substrates, this deterministic graph edit-path subsystem establishes a robust blueprint for future production-grade deployments.

Works cited

1. Experience Memory Graph: One-Shot Error Correction for Agents \- ResearchGate, https://www.researchgate.net/publication/410206669\_Experience\_Memory\_Graph\_One-Shot\_Error\_Correction\_for\_Agents

2. Experience Memory Graph: One-Shot Error Correction for Agents \- arXiv, https://arxiv.org/html/2607.13884v1

3. Time cost of EMG and iterative self-reflection baselines. \- ResearchGate, https://www.researchgate.net/figure/Time-cost-of-EMG-and-iterative-self-reflection-baselines\_fig2\_410206669

4. \[Literature Review\] Experience Memory Graph: One-Shot Error Correction for Agents, https://www.themoonlight.io/review/experience-memory-graph-one-shot-error-correction-for-agents

5. A concrete example for constructing action decision graph. Nodes/ Edges... \- ResearchGate, https://www.researchgate.net/figure/A-concrete-example-for-constructing-action-decision-graph-Nodes-Edges-with-different\_fig4\_410206669

6. jyyang621/DailyArXiv: Thanks to https://github.com/zezhishao/DailyArXiv.git · GitHub \- GitHub, https://github.com/jyyang621/DailyArXiv

7. Computer Science \- arXiv, https://www.arxiv.org/list/cs/new?skip=25\&show=1000

8. EUGENE: Explainable Structure-aware Graph Edit Distance Estimation with Generalized Edit Costs \- arXiv, https://arxiv.org/pdf/2402.05885

9. Fused Gromov-Wasserstein Alignment for Graph Edit Distance Computation and Beyond \- VLDB Endowment, https://www.vldb.org/pvldb/vol18/p3641-tang.pdf

10. Edit distance between two graphs \- algorithm \- Stack Overflow, https://stackoverflow.com/questions/16399597/edit-distance-between-two-graphs

11. DIFFGED: COMPUTING GRAPH EDIT DISTANCE VIA DIFFUSION-BASED GRAPH MATCHING \- OpenReview, https://openreview.net/pdf?id=3bofUSPhNF

12. Shape-of-You: Fused Gromov-Wasserstein Optimal Transport for Semantic Correspondence in-the-Wild \- CVF Open Access, https://openaccess.thecvf.com/content/CVPR2026/papers/Im\_Shape-of-You\_Fused\_Gromov-Wasserstein\_Optimal\_Transport\_for\_Semantic\_Correspondence\_in-the-Wild\_CVPR\_2026\_paper.pdf

13. Gromov–Wasserstein Meets Combinatorial Optimization: A Scalable Solver for the Capacitated Quadratic Assignment Problem \- MDPI, https://www.mdpi.com/2227-7390/14/11/1972

14. Gromov-Wasserstein Learning for Graph Matching and Node Embedding, https://proceedings.mlr.press/v97/xu19b/xu19b.pdf

15. Fused Gromov–Wasserstein Distance with Feature Selection \- arXiv, https://arxiv.org/html/2605.12161

16. Fused Gromov–Wasserstein: Theory & Applications \- Emergent Mind, https://www.emergentmind.com/topics/fused-gromov-wasserstein-fgw

17. Fused Gromov-Wasserstein Distance for Structured Objects \- MDPI, https://www.mdpi.com/1999-4893/13/9/212

18. A Fused Gromov-Wasserstein Framework for Unsupervised Knowledge Graph Entity Alignment \- ACL Anthology, https://aclanthology.org/2023.findings-acl.205.pdf

19. Fused Unbalanced Gromov–Wasserstein-Based Network Distributional Resilience Analysis for Critical Infrastructure Assessment \- MDPI, https://www.mdpi.com/2227-7390/14/3/417

20. \[Literature Review\] Experience Memory Graph: One-Shot Error Correction for Agents, https://www.themoonlight.io/en/review/experience-memory-graph-one-shot-error-correction-for-agents

21. Fused Partial Gromov-Wasserstein for Structured Objects \- arXiv, https://arxiv.org/html/2502.09934v1

22. (PDF) Fused Partial Gromov-Wasserstein for Structured Objects \- ResearchGate, https://www.researchgate.net/publication/389056325\_Fused\_Partial\_Gromov-Wasserstein\_for\_Structured\_Objects

23. Fused Gromov-Wasserstein Transport \- Emergent Mind, https://www.emergentmind.com/topics/fused-gromov-wasserstein-optimal-transport

24. Fused Partial Gromov–Wasserstein for Structured Objects \- arXiv, https://arxiv.org/html/2502.09934v2

25. Partial Gromov Wasserstein Metric \- OpenReview, https://openreview.net/forum?id=nrcFNxF57E¬eId=2yTWrzRMoP

26. Variants of Gromov-Wasserstein — cajal 1.04 documentation \- Read the Docs, https://cajal.readthedocs.io/en/latest/gw\_variants.html

27. Outlier-Robust Gromov-Wasserstein for Graph Data, https://proceedings.neurips.cc/paper\_files/paper/2023/file/4e429936318af03ae99c01c90e2604ec-Paper-Conference.pdf

28. FUSED PARTIAL GROMOV-WASSERSTEIN FOR STRUCTURED OBJECTS | OpenReview, https://openreview.net/forum?id=TwQ4OPhTR6¬eId=xkoIfrtCYW

29. Semidefinite Relaxations of the Gromov-Wasserstein Distance \- NIPS, https://proceedings.neurips.cc/paper\_files/paper/2024/file/8189d86a5d8dea0694d43bb90e01c14d-Paper-Conference.pdf

30. Frank–Wolfe algorithm \- Wikipedia, https://en.wikipedia.org/wiki/Frank%E2%80%93Wolfe\_algorithm

31. “ The Iterates of the Frank-Wolfe Algorithm May Not Converge” \- Toulouse School of Economics, https://www.tse-fr.eu/sites/default/files/TSE/documents/doc/wp/2022/wp\_tse\_1311.pdf

32. An Improved Frank–Wolfe Algorithm to Solve the Tactical Investment Portfolio Optimization Problem \- MDPI, https://www.mdpi.com/2227-7390/13/18/3038

33. Network Design for the Traffic Assignment Problem with Mixed-Integer Frank-Wolfe \- arXiv, https://arxiv.org/html/2402.00166v3

34. sadeqbillah/KuhnMunkres: C\# Implementation of Kuhn Munkres Algorithm. Widely known as Hungarian Algorithm \- GitHub, https://github.com/sadeqbillah/KuhnMunkres

35. Hungarian algorithm \- Wikipedia, https://en.wikipedia.org/wiki/Hungarian\_algorithm

36. Hungarian Algorithm for Assignment Problem (Introduction and Implementation), https://www.geeksforgeeks.org/dsa/hungarian-algorithm-assignment-problem-set-1-introduction/

37. Records \- C\# reference \- Microsoft Learn, https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/record

38. A simplified approach to serializing and deserializing objects in C\# 10 \- C\# Corner, https://www.c-sharpcorner.com/article/a-simplified-approach-to-serializing-and-deserializing-objects-in-c-sharp-10/

39. Property Ordering in C\# JSON Serialization \- Code Maze, https://code-maze.com/csharp-property-ordering-json-serialization/

40. Is JSON serialization deterministic? \- Stack Overflow, https://stackoverflow.com/questions/56434859/is-json-serialization-deterministic

41. Serialize and deserialize JSON using C\# \- .NET \- Microsoft Learn, https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json/overview

42. Custom C\# JSON Deserialisation for Object property Types | ryansouthgate.com, https://ryansouthgate.com/custom-json-serialisation-for-specific-property/

43. DefaultJsonTypeInfoResolver.Modifiers Property (System.Text.Json.Serialization.Metadata), https://learn.microsoft.com/en-us/dotnet/api/system.text.json.serialization.metadata.defaultjsontypeinforesolver.modifiers?view=net-10.0

44. Adding modifiers to System.Text.Json serialization when using source generation, https://stackoverflow.com/questions/79736717/adding-modifiers-to-system-text-json-serialization-when-using-source-generation

45. Allowing customization of JSON key ordering when serializing dictionaries \#2270 \- GitHub, https://github.com/JamesNK/Newtonsoft.Json/issues/2270

46. System.Text.Json: Sort by key Hashtable? \- Stack Overflow, https://stackoverflow.com/questions/73811915/system-text-json-sort-by-key-hashtable

47. How to write custom converters for JSON serialization \- .NET \- Microsoft Learn, https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json/converters-how-to

48. json.net: specify converter for dictionary keys \- Stack Overflow, https://stackoverflow.com/questions/6845364/json-net-specify-converter-for-dictionary-keys

49. C\# Sort JSON string keys \- Stack Overflow, https://stackoverflow.com/questions/14417235/c-sharp-sort-json-string-keys

50. Compare two objects using serialization C\# \- Stack Overflow, https://stackoverflow.com/questions/38411221/compare-two-objects-using-serialization-c-sharp

51. How to customize property names and values with System.Text.Json \- .NET | Microsoft Learn, https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json/customize-properties

52. What's new in System.Text.Json in .NET 7 \- Microsoft Developer Blogs, https://devblogs.microsoft.com/dotnet/system-text-json-in-dotnet-7/

53. Mastering JSON Serialization in C\# with System.Text.Json | by Madhawa Polkotuwa, https://madhawapolkotuwa.medium.com/mastering-json-serialization-in-c-with-system-text-json-01f4cec0440d

54. What's new in System.Text.Json in .NET 8 \- Microsoft Developer Blogs, https://devblogs.microsoft.com/dotnet/system-text-json-in-dotnet-8/

55. BinaryFormatter migration guide: Migrate to System.Text.Json (JSON) \- .NET, https://learn.microsoft.com/en-us/dotnet/standard/serialization/binaryformatter-migration-guide/migrate-to-system-text-json

56. C\# serialization with JsonSchema and System.Text.Json | endjin, https://endjin.com/blog/csharp-serialization-with-system-text-json-schema

57. Custom TypeInfoResolver to manage polymorphic deserialization in System.Text.Json, https://stackoverflow.com/questions/77809445/custom-typeinforesolver-to-manage-polymorphic-deserialization-in-system-text-jso