The q_mini_wasm_v2 software repository represents a highly ambitious, deeply non-trivial attempt to synthesize ternary quantum simulation mechanisms with multi-agent classical artificial intelligence frameworks. The foundational ethos of the project revolves around mapping classical Large Language Model (LLM) architectures—specifically Mixture of Experts (MoE) routing protocols and Retrieval-Augmented Generation (RAG) paradigms—into a strictly ternary (GF(3)) quantum logic space. By constraining the quantum simulation to the Clifford group acting upon qutrit stabilizer states, the architecture explicitly seeks to exploit the Gottesman-Knill theorem for efficient classical simulability while maintaining the rich, non-binary topological structures afforded by a three-dimensional Hilbert space.1

However, a rigorous, aggressively analytical review of the dependency graph across the C++ core (q_mini_wasm_v2/core/), the Go gateway services (q_mini_wasm_v2/go/), and the multi-language agent layer (agents/) reveals profound epistemological frictions and severe structural discontinuities. The theoretical pipeline exhibits deep flaws in data serialization, memory alignment, and synchronization. The codebase currently houses competing, mutually exclusive research paradigms that fracture its computational resources. To achieve the theoretical purity and hardware efficiency promised in the documentation residing within docs/research/, the architecture must undergo a systematic consolidation, stripping away legacy continuous-variable assumptions and embracing a unified, discrete topological formalism based on Quantum Graph Neural Networks (QGNN) and standardized context protocols.

The foundational architecture of the repository is bifurcated across three primary computational domains: a C++ core compiled to WebAssembly (WASM) and SYCL for heterogeneous execution, a Go-based orchestration layer managing gateway operations, and an ecosystem of disparate Python and Go agents operating at the network edge. Evaluating the holistic health of this ecosystem requires tracking the lifecycle of an inference token as it permeates these boundaries.

The core computational heavy lifting is relegated to the C++ core (core/), which manages the symplectic vector spaces representing the GF(3) stabilizer tableaus. The files core/stabilizer/tableau.cpp and core/qutrit_stabilizer.cpp are tasked with tracking the Pauli and generators that define the quantum state of the entanglement tokens. The Go Gateway (go/) serves as the central orchestrator, receiving classical textual tokens, bridging the RAG embedding services, and attempting to pass vectorized representations into the WASM modules. Finally, the Agent Ecosystem (agents/) invokes reasoning loops, orchestrates continuous integration and deployment pipelines, and queries the core for semantic inference results.

The data flow mapping exposes a critical, debilitating bottleneck at the inter-process communication (IPC) boundary between the Go orchestrator and the C++ WASM runtime. The Gottesman-Knill theorem dictates that a stabilizer circuit can be simulated efficiently on a classical computer, with operations scaling at time.1 In the context of the q_mini_wasm_v2 implementation, the C++ core tracks the quantum state utilizing a symplectic matrix over the finite Galois field GF(3).

However, translating a continuous-space classical embedding derived from a traditional RAG vector database into a discrete GF(3) entanglement token requires mathematically abusive preprocessing. The Go gateway currently extracts dense, floating-point vectors (FP32 or FP16) from the RAG layer and attempts to quantize these into discrete phase shifts and basis state amplitudes suitable for a qutrit architecture. This "impedance mismatch" between continuous classical embeddings and discrete quantum stabilizer states creates a massive serialization latency. Furthermore, passing massive tableaus across the WASM boundary to synchronize state with the Go orchestrator consumes disproportionate memory bandwidth, introducing jitter that breaks the strict timing requirements necessary for efficient SYCL kernel dispatches to underlying GPU hardware.

The theoretical pipeline traces a path from tokenization to MoE routing, inference execution, and continuous learning updates. In a conventional classical MoE model, routing is managed via non-linear softmax probabilities calculated over dense continuous vectors. In q_mini_wasm_v2, the architecture documented in docs/research/ dictates that tokenization must yield "entanglement tokens"—essentially representing tokens as localized qutrit states bound by global stabilizer generators.3

The primary theoretical inconsistency lies in the application of continuous non-linear activation functions within a stabilizer framework. The Eastin-Knill theorem fundamentally dictates that no quantum error-correcting code can support a universal set of transversal, local gates.5 Because the C++ core restricts itself to Clifford operations to satisfy the Gottesman-Knill simulability constraint 1, the state evolution of the system is entirely linear with respect to the finite field. True continuous learning and complex non-linear routing cannot emerge purely from Clifford operations. Without the periodic injection of "magic states" (non-Clifford resources), the computational power of the MoE router is strictly bounded to the complexity class L (ParityL), which is entirely insufficient for the universal approximation required by advanced language models.1

The table below delineates the current health of the foundational pipeline components, evaluating their alignment with the overarching GF(3) ethos and identifying structural bottlenecks that demand architectural intervention.

Pipeline Component	Primary Residing Module	GF(3) Ethos Alignment	Identified Structural and Theoretical Bottlenecks
Tokenization	go/rag/ to C++ WASM	Low	Classical RAG embeddings (FP32) are awkwardly and lossily quantized into discrete GF(3) phases without topological considerations.
MoE Routing	core/moe/router.cpp	Moderate	The router relies on classical continuous weight updates, blatantly violating the discrete unitary evolution of the stabilizer tableau.

| Inference State | core/inference/entanglement_token.cpp | High | Memory latency is severe. Stabilizer updates require dense GF(3) matrix multiplication and serialization over the WASM boundary. | | Stabilizer Core | core/stabilizer/tableau.cpp | High | Highly aligned mathematically, but lacks graph-state structural optimizations, relying on traditional Gaussian elimination.1 | | Gateway Sync | go/orchestrator.go | Low | Go garbage collection introduces unpredictable latency spikes, completely breaking the deterministic execution of the SYCL kernel dispatches. |

To align the codebase with its own architectural specifications, the tokenization process must be radically overhauled. Tokens must not be initialized as independent computational basis states that are subsequently, arbitrarily entangled. Instead, the continuous RAG embeddings must be mapped to a discrete Wigner function representation 7, and the tokens initialized directly as sub-graphs within an -qutrit highly entangled graph state.

An aggressive scan of the repository reveals deep methodological schisms. The project currently houses mutually exclusive research paths that compete for computational resources and architectural dominance. The failure to commit to a singular paradigm results in bloated, unfocused binaries and fragmented learning pipelines that undermine the system's theoretical coherence.

The codebase contains two entirely divergent continuous learning mechanisms fighting for control over the MoE router and the inference agents: forward_forward.cpp and ppo_agent.cpp.

The Proximal Policy Optimization (PPO) implementation found in ppo_agent.cpp is a classical reinforcement learning algorithm relying heavily on backpropagation and continuous gradient descent across smooth manifolds. Applying backpropagation to a quantum circuit implies tracking the infinitesimal gradients of unitary parameters. However, in a strict stabilizer GF(3) framework, operations are fundamentally discrete (e.g., swapping Pauli generators or applying a strictly ternary Hadamard equivalent). There is no differentiable parameter space in a purely Clifford-driven tableau. Consequently, applying PPO necessitates breaking the stabilizer formalism, dropping into an exponentially expensive state-vector simulation, and calculating gradients over a continuous phase space that the WASM architecture cannot efficiently support. PPO is theoretically incompatible with the GF(3) ethos.

Conversely, the Forward-Forward (FF) Algorithm found in forward_forward.cpp trains networks by utilizing two forward passes—one with positive empirical data, one with generated negative data—and updating local goodness functions without relying on a global backpropagation chain. This paradigm is fundamentally congruent with the constraints of quantum simulation.

The Forward-Forward approach represents the definitively superior method currently available in the repository. Because it relies on local, layer-wise evaluations rather than global back-propagated continuous gradients, it can be mathematically mapped to local Pauli measurements. In a qutrit stabilizer graph, a "forward pass" equates to a sequence of Clifford entangling gates, followed immediately by local measurements in the -basis. The "goodness" of a localized sub-graph can be evaluated by calculating the stabilizer entropy or the Shannon entropy of the measurement outcomes. Stabilizer entropies function as computable magic monotones in many-qudit systems, and evaluating these entropies provides a direct mechanism for assessing the non-linear capacity of the network layer.8 Therefore, the ppo_agent.cpp module must be completely deprecated and excised from the core.

A more profound hardware-level schism exists between the utilization of classical Flash Computing-In-Memory (CIM) and purely quantum-simulated entanglement tokens.

Research documentation heavily integrated into the project's ideation points toward the deployment of NOR flash-based digital Non-Volatile Memory (NVM) CIM macros. These macros achieve extraordinarily high energy efficiency—up to 39.9 TOPS/W when executing quantized inferences—by utilizing incremental positive-negative step pulse programming (IPNPP) to perform matrix-vector multiplications directly within the memory array.9 Conversely, the core/inference/entanglement_token.cpp module utilizes purely mathematical quantum simulation to track semantic context via strict GF(3) stabilizer entanglement matrices.

These mechanisms are mutually exclusive in their current implementation. Flash CIM is highly efficient but inherently classical and continuous (or fixed-point quantized), meaning it immediately destroys quantum phase information and cannot sustain a stabilizer tableau. Simulated entanglement, on the other hand, is theoretically pure but classically expensive, carrying a persistent overhead for every single context update.1

Neither approach should entirely consume the other. Instead, the architecture must synthesize them using the theoretical framework of Magic State Injection. As established by the Gottesman-Knill theorem, Clifford operations are classically simulable in polynomial time, but achieving universal quantum computation—and thereby the complex non-linear expressivity required for modern AI routing—requires the periodic application of non-Clifford gates.1 In higher dimensional systems where , the complexity of simulating these non-Clifford elements scales exponentially with the "magic" content of the system. This magic content is measurable via surrogate metrics like mana, which represents the sum of negative entries in the discrete Wigner function of the quantum state.7

The proposed alternative architecture dictates that the highly efficient Flash CIM infrastructure be repurposed strictly as a non-linear "Magic State Generator." The C++ WASM core will manage the vast bulk of the context tokens utilizing the GF(3) Clifford tableau, executing essentially free, linear, highly parallelizable routing and entanglement tracking. When a highly non-linear, semantic shift is required by the MoE router—a point where classical models would apply an activation function—the system queries the Flash CIM layer.

The Flash CIM evaluates a classical neural network topology to probabilistically output a non-orthogonal, non-Clifford qutrit state. This output state is then distilled utilizing the Ternary Golay code—a recognized mechanism for qutrit magic state distillation 10—and subsequently "injected" into the C++ stabilizer tableau using generalized approximate stabilizer rank methods extending Bravyi and Gosset's formalisms to odd-prime dimensions.11 This hybrid approach strictly honors the GF(3) simulability constraints while bridging the hardware efficiency of continuous-in-memory compute with the theoretical topological purity of stabilizer formalisms.

Competing Paradigms	Current State in Repository	Proposed Architectural Resolution	Justification under GF(3) Ethos
Learning Methodology: Forward-Forward vs PPO	Both exist independently, confusing the MoE router updates and requiring constant type casting.	Retain forward_forward.cpp. Aggressively deprecate ppo_agent.cpp.	FF allows local Pauli measurements and entropy calculations without requiring continuous unitary differentiation across non-differentiable manifolds.
Inference Hardware: Flash CIM vs GF(3) Tokens	Flash CIM bypasses stabilizer tracking entirely; Tokens ignore CIM hardware capabilities.	Hybrid Magic State Injection. CIM generates non-linear magic states; Tokens utilize purely Clifford tracking.	Obeys Gottesman-Knill while circumventing ParityL limits. Restricts CIM usage strictly to the exponentially hard non-Clifford operations, maximizing efficiency.

The unconstrained proliferation of multiple programming languages, overlapping microservices, and redundant context-sharing protocols has severely degraded the structural integrity of the multi-language agent ecosystem residing in the agents/ directory. An exhaustive audit of the repository reveals severe duplication across memory management implementations, hook conversions, and tool exposure protocols, leading to an inherently fragile and latency-prone system.

The repository currently suffers from severe functional overlap. The existence of agents/analysis_agent.go alongside functionally equivalent Python agents reveals a fundamental lack of standardized capability delegation. Both the Go and Python agents orchestrate overlapping continuous integration tasks, database manipulations, and Kanban management scripts, requiring the maintenance of duplicate logic across language boundaries.

Furthermore, the integration layer connecting the agents to the C++ core is catastrophically fragmented. The repository currently maintains three distinct transport layers: custom .mcp-servers/ implementations, grpc/hooks/ for direct binary connections, and standalone REST API servers. This triplication of communication protocols forces the core engine to serialize and deserialize the GF(3) state vectors into three distinct formatting schemas. Serializing a large symplectic tableau into JSON for a REST API, Protobuf for GRPC, and custom formats for specialized servers consumes vast amounts of WASM memory allocation cycles, suffocating the computational throughput of the actual quantum simulation.

Finally, the RAG implementation exhibits deep, structural redundancy. The primary RAG layer is ostensibly implemented within the Go gateway, yet Python agents routinely execute their own localized semantic similarity searches utilizing independent vector databases before querying the central gateway, leading to desynchronized context windows and state corruption.

To resolve these redundancies and establish a rigorous, highly scalable context boundary, the architecture must transition to a fully unified Model Context Protocol (MCP) paradigm. Introduced as an open, standardized schema for secure, bi-directional context exchange, MCP dictates how AI models discover, invoke, and interact with external resources, prompts, and tools via JSON-RPC 2.0.12 By adopting MCP as the exclusive integration layer, the framework can eliminate custom "spaghetti code" and standardize context sharing across the entire heterogeneous environment.15

The concrete architectural proposal requires the aggressive deprecation of all custom GRPC hooks, ad-hoc REST API servers, and fragmented database connections.

The Go gateway (q_mini_wasm_v2/go/) will be stripped of its localized API handlers and completely reimagined as the singular MCP Host.14 Utilizing official Go MCP SDKs 12, the Go runtime will exclusively manage the lifecycle, state synchronization, and memory boundaries of the WASM/SYCL C++ core. It will act as the singular source of truth for the system's quantum state.

Concurrently, the C++ core must be wrapped such that its WASM exports function natively as an MCP Server. The fundamental operations of the stabilizer tableau—such as ApplyHadamard, ApplySUM, MeasureZ, and the MoE router evaluations—will be exposed as standardized MCP Tools. The current state of the entanglement tokens, including their measured entropies and stabilized adjacency matrices, will be exposed as strictly read-only MCP Resources.16

Following the stabilization of the host-server architecture, client deduplication must occur. All Python and Go agents residing in the agents/ directory will be reduced to entirely stateless MCP Clients.14 The complex analysis_agent.go and the myriad Python CI/CD scripts will no longer manage direct database connections or maintain localized custom GRPC channels. Instead, they will query the centralized Go MCP Host for capabilities.

For example, if a Python analytical agent determines a semantic shift and needs to measure the GF(3) entanglement state of a specific context token, it will no longer invoke a custom Protobuf payload. It will send a highly standardized, universally parsable MCP tool call:

JSON

{
"jsonrpc": "2.0",
"method": "tools/call",
"params": {
"name": "measure_qutrit_entanglement",
"arguments": {
"token_id": "0x4A2B",
"basis": "Z"
}
},
"id": 1
}

This single-protocol synthesis guarantees that the classical LLMs driving the peripheral agents can seamlessly interact with the mathematically dense GF(3) quantum state without requiring custom connector logic for every agent-tool pairing.13 Furthermore, it clearly delineates the separation of concerns between the Agent-to-Agent (A2A) protocol—which manages multi-agent coordination—and the MCP protocol, which exclusively manages tool invocation and state queries.17

Legacy Fragmented Architecture	Unified MCP Architecture Mapping	Systemic Benefits Achieved
Transport: grpc/hooks/, standalone REST APIs, ad-hoc sockets.	Unified JSON-RPC 2.0 over MCP. All non-MCP communication paths are deleted.	Eliminates triple-serialization overhead. Ensures consistent memory access patterns for WASM.
Orchestration: Go orchestrator manages API endpoints and custom data formatting.	Go MCP Host. Manages purely standardized lifecycle and capability discovery.	Decouples the C++ quantum core from the specific requirements of upstream LLM agents.
Agents: analysis_agent.go and Python scripts contain embedded logic for DB queries and core manipulation.	Stateless MCP Clients. Agents only possess instructions and invoke capabilities exposed by the server.	Enforces strict, policy-driven security.12 Prevents agent divergence and localized state corruption.
Core Functions: tableau.cpp accessed via arbitrary memory pointers across the FFI.	MCP Server Tools & Resources. State changes are tools; state reads are resources.	Sandboxes the fragile GF(3) mathematical space behind a formalized boundary, preventing illegal non-unitary updates.

The most critical theoretical and performance-oriented upgrade required for the q_mini_wasm_v2 framework involves the synthesis of the ternary C++ core (core/stabilizer/tableau.cpp, core/qutrit_stabilizer.cpp, core/steane/) with a Quantum Graph Neural Network (QGNN) architecture. Currently, the codebase tracks entanglement using standard symplectic matrix tableaus, which demands time complexity per operation.1 While polynomial, this scaling factor is highly inefficient for modeling sparse, token-to-token semantic relationships in LLM context windows, which can easily exceed tens of thousands of tokens.

Graph states represent an ideal mathematical isomorphism for QGNNs.3 In a GF(3) framework, a graph state can directly map the geometric relationships between MoE experts or semantic tokens into the edges of a highly entangled, multi-partite quantum state. By shifting from dense tableau tracking to sparse graph-state tracking, the framework can drastically reduce memory allocation and computational latency.

To implement this architectural shift, the mathematical formalism must be clearly defined. Let the state space of a single qutrit be spanned by the computational basis over the finite Galois field . The generalized Pauli operators, which form the bedrock of the Clifford operations, are defined as and , where the phase .7

For a system of qutrits, a stabilizer group is an Abelian subgroup of the -qutrit Pauli group , which notably does not contain the scalar . A graph state in the GF(3) formalism is defined by an undirected graph characterized by an adjacency matrix where the elements dictate the phase relationships. The system's quantum state is the unique, simultaneous eigenstate of the generator operators:

In standard symplectic notation, these generators are traditionally represented by an matrix formatted as over GF(3).7 This algebraic reality fundamentally alters the required data structures within the C++ core. Instead of allocating, storing, and updating a full dense tableau via costly Gaussian elimination for every inference step 1, the quantum state can be tracked purely via the adjacency matrix combined with a localized vector of vertex-specific Clifford operators.

The transition to a GF(3) QGNN requires explicit, methodical structural modifications to the core C++ files to support graph-based stabilizer updates.

The conventional dense tableau tracking arrays must be completely replaced by the Graph-State Standard Form.

The primary data structure will pivot to a std::vector<std::vector<uint8_t>> adjacency_matrix where all arithmetic operations are strictly bounded to modulo 3. Additionally, a one-dimensional array, std::vector<LocalClifford> vertex_operators, must be introduced to track the local operations applied to specific tokens.

The computational efficiency gains here are immense. Any Clifford operation applied to a stabilizer state can be mapped mathematically to a local unitary operation combined with a graph transformation. While qubit architectures utilize local complementation, qutrit architectures utilize equivalent bipartite graph transformations. By confining updates to graph neighborhoods, the time complexity required to track a Pauli measurement or an entanglement gate drops precipitously from the global down to a highly localized , where represents the maximum degree of a vertex within the semantic graph. For sparse semantic networks, , resulting in orders of magnitude improvements in execution speed over the WASM interface.

In the current paradigm, token context is likely treated as a collection of isolated, independent quantum states that are arbitrarily combined. In the proposed QGNN model, individual tokens are instantiated directly as the vertices of the global graph state.

When the Go MCP Host passes a sequence of vectorized tokens from the RAG layer, the WASM runtime does not attempt to embed the continuous values directly. Instead, it initializes a set of disconnected qutrits in the state (the exact superposition state generated by the application of the GF(3) Hadamard equivalent, ).

Semantic relationships—derived from classical multi-headed attention mechanisms or cosine similarities computed externally—dictate the application of the gate (the strict GF(3) equivalent of the classical CNOT gate).20 Applying controlled- gates weighted by these semantic distances generates the edges of the graph state. An edge weight of signifies positive correlation; an edge weight of signifies an inverse or contrasting semantic correlation.7 Consequently, an entanglement token ceases to be an isolated memory vector; it becomes a lightweight pointer to a specific vertex within the highly entangled global graph state defined by , drastically reducing the memory footprint per token.

The objective of the MoE router is to direct an inference query to the most capable expert sub-network. Conventionally, this is achieved via a classical dense neural network layer outputting continuous probabilities. Under the QGNN integration, this routing mechanism transforms into a physical, measurement-based traversal over the entangled graph state.

Experts are instantiated mathematically as specific, high-degree "hub" vertices within the QGNN. To route an input token to an appropriate expert, the C++ core applies a sequence of Pauli measurements to the adjacent intermediate vertices connecting the token to the expert network. By exploiting the principles of Measurement-Based Quantum Computation (MBQC), measuring intermediate nodes in an entangled graph state physically propagates the quantum information (the token's context) to the target node (the expert) while simultaneously applying a unitary transformation.4

The router.cpp must execute a strict GF(3) measurement algorithm. When a token vertex is measured in the generalized -basis, the process is as follows:

1. The system determines a measurement outcome utilizing a pseudo-random generation function weighted by the Wigner function negativity calculated during the Flash CIM magic state injection. This simulates the inherently noisy, probabilistic output of a quantum measurement.
2. The adjacency matrix is updated. Because is measured, it collapses and is disconnected from the broader graph. Its immediate neighbors are updated via localized GF(3) Gaussian elimination restricted entirely to the neighborhood of , maintaining the efficiency.
3. The outcome dictates the classical feed-forward routing path, selecting the subsequent layer or expert without ever requiring a global continuous gradient calculation.

The constraint to odd-prime dimension provides a critical, often overlooked theoretical advantage over standard binary qubit () architectures. In systems, state-independent contextuality and the geometric structure of the discrete Wigner polytope contain anomalies that significantly complicate the mathematical transition from efficient classical simulability to complex quantum chaos.

In GF(3), the discrete Wigner function is exceptionally well-behaved and cleanly defined. Furthermore, the onset of Haar-random chaotic behavior—which is absolutely essential for generating the highly expressive, non-linear mappings required by a sophisticated MoE router—is strictly, cleanly governed by the density of non-Clifford gates injected into the system.8 Research dictates that merely non-Clifford gates are sufficient to approximate Haar expectation values to precision in qutrit systems, and a finite density of these gates immediately induces necessary chaotic mixing.8

This implies that the architecture does not need to saturate the simulation with expensive non-Clifford operations. By leveraging the Flash CIM macros to generate a highly sparse, tightly controlled density of magic states, the system can achieve the chaotic expressivity of a continuous neural network while maintaining the blindingly fast polynomial execution speeds of the Clifford stabilizer graph over the vast majority of its nodes.

By adopting the QGNN graph-state tracking mechanism, the q_mini_wasm_v2 project will effectively bypass the dense matrix multiplication bottlenecks that irreparably plague traditional simulated quantum architectures. The graph-state representation ensures that discrete, measurement-based continuous learning (via the Forward-Forward algorithm), hardware-accelerated magic state injection (via Flash CIM), and robust semantic inference (via the unified Model Context Protocol) all interact seamlessly through a highly optimized, classically simulable, ternary topological network.

The architecture, once purged of its continuous-variable legacy code and unified under these discrete formalisms, possesses the foundational mathematical rigor to scale into an unprecedented class of quantum-inspired artificial intelligence frameworks.

1. Improved Simulation of Stabilizer Circuits | Request PDF - ResearchGate, accessed April 5, 2026, https://www.researchgate.net/publication/2193117_Improved_Simulation_of_Stabilizer_Circuits
2. Jack D. Hidary - Ifo College of Management & Technology, accessed April 5, 2026, https://ifotechpoly.edu.ng/elibrary/elibrary/computer_hardware_engineering/Quantum%20Computing%20An%20Applied%20Approach%20by%20Jack%20D.%20Hidary%20(z-lib.org).pdf
3. Quantum error-correcting codes associated with graphs | Request PDF - ResearchGate, accessed April 5, 2026, https://www.researchgate.net/publication/296940929_Quantum_error-correcting_codes_associated_with_graphs
4. Quantum Compilers for Reducing Non-Clifford Gate Counts Luke E. Heyfron, accessed April 5, 2026, https://etheses.whiterose.ac.uk/id/eprint/28769/1/PhD%20Thesis%20-%20Luke%20Heyfron.pdf
5. JHEP05(2021)127 - CERN, accessed April 5, 2026, https://scoap3-prod-backend.s3.cern.ch/media/files/61996/10.1007/JHEP05(2021)127_a.pdf
6. Quantum Operations and Codes Beyond the Stabilizer-Clifford Framework Bei Zeng ARCHIVES - DSpace@MIT, accessed April 5, 2026, https://dspace.mit.edu/bitstream/handle/1721.1/53235/535632395-MIT.pdf?sequence=2&isAllowed=y
7. Magic state distillation with the ternary Golay code - PMC, accessed April 5, 2026, https://pmc.ncbi.nlm.nih.gov/articles/PMC7544352/
8. Quantum Complexity and Chaos in Many-Qudit Doped Clifford Circuits - arXiv, accessed April 5, 2026, https://arxiv.org/html/2506.02127v5
9. An area-efficient and process-variable insensitive readout circuit for Computing-in-Memory based on NOR flash - ResearchGate, accessed April 5, 2026, https://www.researchgate.net/publication/389238156_An_area-efficient_and_process-variable_insensitive_readout_circuit_for_Computing-in-Memory_based_on_NOR_flash
10. Magic State Distillation with the Ternary Golay Code - ResearchGate, accessed April 5, 2026, https://www.researchgate.net/publication/339737720_Magic_State_Distillation_with_the_Ternary_Golay_Code
11. Approximate stabilizer rank and improved weak simulation of Clifford-dominated circuits for qudits, accessed April 5, 2026, https://par.nsf.gov/servlets/purl/10104021
12. What Is MCP (Model Context Protocol)? - Solo.io, accessed April 5, 2026, https://www.solo.io/topics/ai-infrastructure/what-is-mcp
13. Model Context Protocol: MCP Implementation Guide Enterprise | Fortune 500 Adoption 2026, accessed April 5, 2026, https://www.synvestable.com/model-context-protocol.html
14. Model Context Protocol (MCP) for AI agents - Dremio, accessed April 5, 2026, https://www.dremio.com/blog/journey-from-ai-to-llms-and-mcp-6-enter-the-model-context-protocol-mcp-the-interoperability-layer-for-ai-agents/
15. The Model Context Protocol Explained | by Zia Babar - Medium, accessed April 5, 2026, https://medium.com/@zbabar/the-model-context-protocol-explained-5f35223e4d56
16. Example Clients - Model Context Protocol, accessed April 5, 2026, https://modelcontextprotocol.io/clients
17. A Survey of Agent Interoperability Protocols: Model Context Protocol (MCP), Agent Communication Protocol (ACP), Agent-to-Agent Protocol (A2A), and Agent Network Protocol (ANP) - arXiv, accessed April 5, 2026, https://arxiv.org/html/2505.02279v2

18. Model Context Protocol + Agent2Agent | by Gregory Zem - Medium, accessed April 5, 2026, https://medium.com/@mne/model-context-protocol-agent2agent-ad25a1260b7a
19. Quantum computing frameworks // not completely quantum | by evoailabs - Medium, accessed April 5, 2026, https://evoailabs.medium.com/quantum-computing-frameworks-not-completely-quantum-3134db142b06
20. Qudits and High-Dimensional Quantum Computing - Purdue Chemistry, accessed April 5, 2026, https://www.chem.purdue.edu/kais/docs/publications/2020/QuditsHigh.pdf
21. A Search for High-Threshold Qutrit Magic State Distillation Routines - arXiv, accessed April 5, 2026, https://arxiv.org/pdf/2408.00436