quantum-system-architecture - SKILL.md Agent Skill

name: quantum-system-architecture description: "Quantum system architecture design skill - systems engineering approach to quantum computing. Covers hybrid quantum-classical systems, dataflow frameworks, distributed quantum computing models, fault-tolerant architecture (FTQC), resource optimization strategies, and quantum error correction with gauge theory. Use for: (1) Designing hybrid quantum-classical computing systems, (2) Dataflow graph program representation, (3) Distributed quantum network architecture, (4) FTQC floorplan optimization, (5) Quantum error correction with quantum reference frames. Activation: quantum architecture, quantum system design, FTQC architecture, distributed quantum computing, quantum dataflow, 混合量子经典架构, 量子系统设计."

Quantum System Architecture

Systems engineering approach to quantum computing architecture design. Covers hybrid quantum-classical systems, distributed quantum computing, fault-tolerant architectures, and resource optimization strategies.

Activation Keywords

quantum architecture
quantum system design
FTQC architecture
distributed quantum computing
quantum dataflow
hybrid quantum-classical
quantum floorplan
quantum error correction gauge
混合量子经典架构
量子系统设计
量子架构
分布式量子计算

Tools Used

exec: Run architecture simulations, Python analysis scripts
read: Load architecture specifications, reference documents
write: Create architecture designs, floorplan proposals
edit: Modify existing architecture files

Core Concepts

1. Hybrid Quantum-Classical Computing

Dataflow Framework (Tierkreis Pattern)

# Higher-order dataflow graph representation
class QuantumDataflowGraph:
    """
    Dataflow graph for hybrid quantum-classical algorithms.
    
    Key features:
    - Compositional design
    - Automatic parallelism
    - Strong static typing
    - Higher-order semantics
    - Flexible runtime protocol
    """
    
    def __init__(self):
        self.nodes = {}  # Node ID -> Operation
        self.edges = []  # Data flow edges
        self.types = {}  # Type constraints
    
    def add_quantum_node(self, qubits, operation):
        """Add quantum computation node"""
        return Node(type='quantum', qubits=qubits, op=operation)
    
    def add_classical_node(self, operation):
        """Add classical computation node"""
        return Node(type='classical', op=operation)
    
    def connect(self, source, target, data_type):
        """Connect nodes with typed edge"""
        self.edges.append(Edge(source, target, data_type))

Design Principles:

Remote quantum computer support
Cloud/distributed computing integration
Long-running algorithm optimization
Automatic parallelism extraction
Third-party extensibility

2. Distributed Quantum Computing Models

LOCAL Model Analysis

# Quantum-LOCAL model comparison
class DistributedQuantumModel:
    """
    Distributed quantum computing models:
    - LOCAL: Unconstrained computation + bandwidth
    - Quantum-LOCAL: Quantum advantage in bandwidth-limited networks
    - Distance-constrained: Latency-dominated scenarios
    """
    
    models = {
        'LOCAL': {
            'constraints': 'distance only',
            'quantum_advantage': 'unknown',
            'applications': 'large-scale distributed'
        },
        'bandwidth_limited': {
            'constraints': 'bandwidth + distance',
            'quantum_advantage': 'established',
            'applications': 'quantum distributed networks'
        }
    }

Key Insight: Quantum advantage established in bandwidth-limited networks, but limitations in distance-constrained LOCAL model.

3. FTQC Architecture Design

Load/Store Architecture (LSQCA Pattern)

# Fault-tolerant quantum computer floorplan
class FTQCFloorplan:
    """
    Resource-efficient FTQC architecture.
    
    Key optimization:
    - Reduce memory overhead (50% → optimized)
    - Unit-time random access to logical qubits
    - Load/Store operations for logical qubits
    """
    
    def design_floorplan(self, n_logical_qubits, connectivity):
        """
        Floorplan strategy:
        1. Minimize overhead qubits
        2. Ensure fault-tolerant logical operations
        3. Optimize qubit connectivity
        4. Balance memory vs computation
        """
        overhead_ratio = self.calculate_overhead(n_logical_qubits)
        return Floorplan(
            data_qubits=n_logical_qubits,
            overhead_qubits=int(n_logical_qubits * overhead_ratio),
            connectivity=connectivity
        )

Resource Efficiency:

Memory overhead reduction strategies
Logical qubit access patterns
Encoding technique selection (surface code, etc.)
Connectivity optimization

4. Quantum Error Correction with Gauge Theory

Quantum Reference Frames Pattern

# Gauge theory as error correction resource
class GaugeQECCode:
    """
    Quantum error correction via gauge symmetry.
    
    Connection: Gauge theories ↔ Stabilizer codes
    Key insight: Redundancy as information protection resource
    """
    
    def construct_qed_code(self, lattice_config):
        """
        Lattice QED error correction:
        1. Define gauge group (Abelian)
        2. Construct recovery operations
        3. Use quantum reference frames (QRFs)
        4. Handle ideal vs non-ideal QRFs
        """
        gauge_group = self.define_abelian_gauge_group()
        recovery_ops = self.group_theoretical_recovery(gauge_group)
        
        return QECCStructure(
            gauge_group=gauge_group,
            recovery_operations=recovery_ops,
            qrf_type='ideal_or_non_ideal'
        )

Theoretical Foundation:

Gauge symmetry = redundancy = protection resource
Quantum reference frames for error correction
Abelian gauge group recovery operations
Stabilizer code correspondence

Usage Patterns

Pattern 1: Hybrid System Design

设计一个混合量子-经典计算系统用于 VQE 算法

Workflow:

Identify quantum vs classical computation boundaries
Design dataflow graph structure
Define typed interfaces
Plan distributed execution
Optimize parallelism

Pattern 2: FTQC Floorplan Optimization

优化一个 1000 逻辑量子比特的 FTQC 架构

Workflow:

Calculate memory overhead requirements
Design Load/Store architecture
Select encoding technique
Optimize connectivity
Validate fault tolerance

Pattern 3: Distributed Quantum Network

分析分布式量子计算网络的局限性

Workflow:

Identify network constraints (bandwidth vs distance)
Select appropriate model (LOCAL vs bandwidth-limited)
Analyze quantum advantage potential
Design network architecture
Evaluate scalability

Instructions for Agents

Step 1: Understand Architecture Type

Determine the architecture focus:

Hybrid quantum-classical → Dataflow framework
Distributed quantum → LOCAL model analysis
FTQC → Floorplan optimization
Error correction → Gauge theory approach

Step 2: Apply Relevant Pattern

Load appropriate reference:

Hybrid systems: See references/dataflow-framework.md
FTQC: See references/ftqc-architecture.md
Distributed: See references/distributed-quantum.md
Error correction: See references/gauge-qec.md

Step 3: Design Architecture

Create architecture specification:

Define system components
Specify interfaces and data types
Design optimization strategies
Plan resource allocation
Validate constraints

Step 4: Validate and Refine

Check architecture properties:

Fault tolerance requirements
Resource efficiency
Scalability limits
Quantum advantage preservation

Key References

Tierkreis (arXiv:2211.02350) - Dataflow framework for hybrid quantum-classical
LSQCA (arXiv:2412.20486) - Load/Store FTQC architecture
Limits of Distributed Quantum (arXiv:2503.11394) - LOCAL model analysis
Error Correction in Lattice QED (arXiv:2604.06149) - Gauge theory QEC

Related Skills

quantum-algorithm-framework-designer - Algorithm-level design
quantum-neural-architecture - Neural network quantum architectures
quantum-framework-agnostic-design - Framework selection

Resources

sqlite-knowledge-graph
kg.db - Paper knowledge base