Add AnyBell depolarising distributor

Author: Bart van der Vecht

examples/stack/teleport/config.yaml

@@ -25,15 +25,13 @@ stacks:
       host_qnos_latency: 1e5
 
 link_cfg: &link_cfg
-  length_A: 0.01
-  length_B: 0.01
-  full_cycle: 1e6
-  cycle_time: 1e3
-  alpha: 0.9
+  fidelity: 0.8
+  prob_success: 0.01
+  t_cycle: 1.e+6
 
 links:
   - stack1: sender
     stack2: receiver
-    typ: nv
+    typ: depolarise_any_bell
     cfg:
       <<: *link_cfg

examples/stack/teleport/example_teleport.py

@@ -1,22 +1,16 @@
 from __future__ import annotations
 
-import math
 import os
 from typing import Any, Dict, Generator, List
 
 import netsquid as ns
 from netqasm.lang.ir import BreakpointAction, BreakpointRole
 from netqasm.sdk.qubit import Qubit
 from netqasm.sdk.toolbox import set_qubit_state
-from netsquid.qubits import ketstates, operators, qubit, qubitapi
+from netsquid.qubits import operators, qubitapi
 
 from pydynaa import EventExpression
-from squidasm.run.stack.config import (
-    GenericQDeviceConfig,
-    LinkConfig,
-    StackConfig,
-    StackNetworkConfig,
-)
+from squidasm.run.stack.config import StackNetworkConfig
 from squidasm.run.stack.run import run
 from squidasm.sim.stack.common import LogManager
 from squidasm.sim.stack.csocket import ClassicalSocket
@@ -154,6 +148,5 @@ def do_teleportation(
 
     link.cfg["fidelity"] = 0.8
 
-    for _ in range(2):
-        fidelities = do_teleportation(cfg, num_times=10, theta=0, phi=0)
-        print(fidelities)
+    fidelities = do_teleportation(cfg, num_times=10, theta=0, phi=0)
+    print(fidelities)

squidasm/run/stack/config.py

@@ -134,6 +134,16 @@ def from_file(cls, path: str) -> DepolariseLinkConfig:
         return _from_file(path, DepolariseLinkConfig)
 
 
+class DepolariseAnyBellLinkConfig(BaseModel):
+    fidelity: float
+    prob_success: float
+    t_cycle: float
+
+    @classmethod
+    def from_file(cls, path: str) -> DepolariseAnyBellLinkConfig:
+        return _from_file(path, DepolariseAnyBellLinkConfig)
+
+
 class NVLinkConfig(BaseModel):
     length_A: float
     length_B: float

squidasm/run/stack/run.py

@@ -4,6 +4,9 @@
 from typing import Any, Dict, List
 
 import netsquid as ns
+import numpy as np
+from netsquid.qubits.ketstates import BellIndex
+from netsquid.qubits.state_sampler import StateSampler
 from netsquid_magic.link_layer import (
     MagicLinkLayerProtocol,
     MagicLinkLayerProtocolWithSignaling,
@@ -12,13 +15,16 @@
 from netsquid_magic.magic_distributor import (
     DepolariseWithFailureMagicDistributor,
     DoubleClickMagicDistributor,
+    MagicDistributor,
     PerfectStateMagicDistributor,
 )
+from netsquid_magic.state_delivery_sampler import HeraldedStateDeliverySamplerFactory
 from netsquid_nv.magic_distributor import NVSingleClickMagicDistributor
 from netsquid_physlayer.heralded_connection import MiddleHeraldedConnection
 
 from squidasm.run.stack.build import build_generic_qdevice, build_nv_qdevice
 from squidasm.run.stack.config import (
+    DepolariseAnyBellLinkConfig,
     DepolariseLinkConfig,
     GenericQDeviceConfig,
     HeraldedLinkConfig,
@@ -32,6 +38,79 @@
 from squidasm.sim.stack.stack import NodeStack, StackNetwork
 
 
+class DepolariseWithFailureAnyBellStateSamplerFactory(
+    HeraldedStateDeliverySamplerFactory
+):
+    def __init__(self):
+        super().__init__(func_delivery=self._delivery_func)
+
+    @staticmethod
+    def _delivery_func(prob_max_mixed, prob_success, **kwargs):
+        bell00 = np.array(
+            [[0.5, 0, 0, 0.5], [0, 0, 0, 0], [0, 0, 0, 0], [0.5, 0, 0, 0.5]],
+            dtype=np.complex,
+        )
+        bell01 = np.array(
+            [[0, 0, 0, 0], [0, 0.5, 0.5, 0], [0, 0.5, 0.5, 0], [0, 0, 0, 0]],
+            dtype=np.complex,
+        )
+        bell10 = np.array(
+            [[0, 0, 0, 0], [0, 0.5, -0.5, 0], [0, -0.5, 0.5, 0], [0, 0, 0, 0]],
+            dtype=np.complex,
+        )
+        bell11 = np.array(
+            [[0.5, 0, 0, -0.5], [0, 0, 0, 0], [0, 0, 0, 0], [-0.5, 0, 0, 0.5]],
+            dtype=np.complex,
+        )
+        maximally_mixed = np.array(
+            [[0.25, 0, 0, 0], [0, 0.25, 0, 0], [0, 0, 0.25, 0], [0, 0, 0, 0.25]],
+            dtype=np.complex,
+        )
+        bell00_noisy = (1 - prob_max_mixed) * bell00 + prob_max_mixed * maximally_mixed
+        bell01_noisy = (1 - prob_max_mixed) * bell01 + prob_max_mixed * maximally_mixed
+        bell10_noisy = (1 - prob_max_mixed) * bell10 + prob_max_mixed * maximally_mixed
+        bell11_noisy = (1 - prob_max_mixed) * bell11 + prob_max_mixed * maximally_mixed
+        return (
+            StateSampler(
+                qreprs=[bell00_noisy, bell01_noisy, bell10_noisy, bell11_noisy],
+                probabilities=[0.25, 0.25, 0.25, 0.25],
+                labels=[
+                    BellIndex.PHI_PLUS,
+                    BellIndex.PSI_PLUS,
+                    BellIndex.PSI_MINUS,
+                    BellIndex.PHI_MINUS,
+                ],
+            ),
+            prob_success,
+        )
+
+
+class DepolariseWithFailureAnyBellMagicDistributor(MagicDistributor):
+    def __init__(self, nodes, prob_max_mixed, prob_success, **kwargs):
+        self.prob_max_mixed = prob_max_mixed
+        self.prob_success = prob_success
+        super().__init__(
+            delivery_sampler_factory=DepolariseWithFailureAnyBellStateSamplerFactory(),
+            nodes=nodes,
+            **kwargs,
+        )
+
+    def add_delivery(self, memory_positions, **kwargs):
+        return super().add_delivery(
+            memory_positions=memory_positions,
+            prob_max_mixed=self.prob_max_mixed,
+            prob_success=self.prob_success,
+            **kwargs,
+        )
+
+    def get_bell_state(self, midpoint_outcome):
+        try:
+            status, label = midpoint_outcome
+        except ValueError:
+            raise ValueError("Unknown midpoint outcome {}".format(midpoint_outcome))
+        return label
+
+
 def fidelity_to_prob_max_mixed(fid: float) -> float:
     return (1 - fid) * 4.0 / 3.0
 
@@ -80,6 +159,17 @@ def _setup_network(config: StackNetworkConfig) -> StackNetwork:
                 prob_success=link_cfg.prob_success,
                 t_cycle=link_cfg.t_cycle,
             )
+        elif link.typ == "depolarise_any_bell":
+            link_cfg = link.cfg
+            if not isinstance(link_cfg, DepolariseAnyBellLinkConfig):
+                link_cfg = DepolariseAnyBellLinkConfig(**link.cfg)
+            prob_max_mixed = fidelity_to_prob_max_mixed(link_cfg.fidelity)
+            link_dist = DepolariseWithFailureAnyBellMagicDistributor(
+                nodes=[stack1.node, stack2.node],
+                prob_max_mixed=prob_max_mixed,
+                prob_success=link_cfg.prob_success,
+                t_cycle=link_cfg.t_cycle,
+            )
         elif link.typ == "nv":
             link_cfg = link.cfg
             if not isinstance(link_cfg, NVLinkConfig):