Tutorial 9 — Distributed Quantum Computing: Mesh vs Ring

Objective: Run the same 3-party computation under mesh and ring coordination topologies to compare latency, fidelity, and resource usage trade-offs.

The choice of coordination topology directly affects performance: mesh provides direct pairwise links but consumes more resources; ring uses fewer links but requires sequential message passing through intermediate nodes.

Define the Two Topologies

from qnet_core import QNetEngine, NodeDefinition, LinkDefinition, CoordinationTopology, MeasurementBasis, BasisType

participants = ["Alice", "Bob", "Charlie"]
basis = MeasurementBasis(basis_type=BasisType.GHZ, correlation_strength=0.85)

# Mesh: all-party pairwise links (more resources, lower latency)
mesh_links = [
    LinkDefinition("Alice", "Bob", distance_km=10.0, base_fidelity=0.95, generation_rate_hz=1_000.0),
    LinkDefinition("Bob", "Charlie", distance_km=10.0, base_fidelity=0.93, generation_rate_hz=1_000.0),
    LinkDefinition("Charlie", "Alice", distance_km=12.0, base_fidelity=0.92, generation_rate_hz=900.0),
]

# Ring: only a cycle (fewer links, higher coordination latency)
ring_links = [
    LinkDefinition("Alice", "Bob", distance_km=10.0, base_fidelity=0.95, generation_rate_hz=1_000.0),
    LinkDefinition("Bob", "Charlie", distance_km=10.0, base_fidelity=0.93, generation_rate_hz=1_000.0),
]

nodes = [
    NodeDefinition(id="Alice",   memory_lifetime_t2=0.8),
    NodeDefinition(id="Bob",     memory_lifetime_t2=0.8),
    NodeDefinition(id="Charlie", memory_lifetime_t2=0.8),
]


def run_comparison(label, link_list, coord_type):
    engine = QNetEngine()
    engine.define_network(nodes, link_list)

    if coord_type == "mesh":
        coordination = CoordinationTopology.mesh()
    else:
        coordination = CoordinationTopology.ring()

    result = engine.run_distributed_computation(
        participants=participants,
        coordination_topology=coordination,
        measurement_basis=basis,
        classical_relay_latency_ms=5.0,
    )

    print(f"\n=== {label} ===")
    print(f"Success:                {result.success}")
    print(f"Computation fidelity:   {result.computation_fidelity:.4f}")
    print(f"Total latency:          {result.total_latency_ms:.1f} ms")
    print(f"Coordination overhead:  {result.coordination_overhead_ms:.1f} ms")
    print(f"Links used:             {len(result.resource_links_used)}")


run_comparison("Mesh Topology", mesh_links, "mesh")
run_comparison("Ring Topology", ring_links, "ring")

Comparison Results Interpretation

Metric	Mesh Advantage	Ring Advantage
Links used	More (3 vs 2 for 3 parties)	Fewer resources
Latency	Lower (parallel coordination)	Higher (sequential relay)
Fidelity	Often higher (more direct paths)	May be lower (longer paths)
Scalability	O(n²) links required	O(n) links — better scaling

Trade-off Summary

Mesh:  Resources = n(n-1)/2  |  Coordination = parallel
Ring:  Resources = n           |  Coordination = sequential (n-1 hops)
Star:  Resources = n-1         |  Coordination = via center node

For small networks (3–4 nodes), mesh usually wins on performance. For larger networks, ring or star topology is more practical due to fewer required links.

What's next

• Authoring a .qnet File — persist network configurations
• Validating a .qnet File — catch errors before simulation