examples: add a second generation repeater

The quantum repeater from https://arxiv.org/pdf/0809.3629.pdf with
repetition code is modelled.

fixes: #91

Author: atomgardner

examples/repeater/second_gen_with_repetition_code.py

@@ -0,0 +1,246 @@
+from dataclasses import dataclass
+from statistics import mode
+
+from qunetsim.components import Host
+from qunetsim.objects import Logger, Qubit
+from qunetsim.components import Network
+
+Logger.DISABLED = True
+
+
+@dataclass()
+class Ebit:
+    val: tuple[int, int]
+
+    def __str__(self):
+        return {
+            (0, 0): "phi+",
+            (0, 1): "psi+",
+            (1, 0): "phi-",
+            (1, 1): "psi-",
+        }[self.val]
+
+    @staticmethod
+    def from_bell_measurement(a: Qubit, b: Qubit):
+        a.cnot(b)
+        a.H()
+        x = a.measure()
+        y = b.measure()
+        return Ebit((x, y))
+
+
+def send_epr(host, peer):
+    a, b = Qubit(host), Qubit(host)
+    a.H()
+    a.cnot(b)
+    host.send_qubit(peer.host_id, b)
+    return a
+
+
+@dataclass(init=False)
+class RepetitionCodedQubit:
+    physical: list[Qubit]
+
+    def __init__(self, h: Host):
+        self.physical = [Qubit(h), Qubit(h), Qubit(h)]
+
+    def __getitem__(self, index):
+        return self.physical[index]
+
+    def H(self):  # this maps ⌈|0>⌋ to ⌈|+>⌋
+        self.physical[0].H()
+        self.physical[0].cnot(self.physical[1])
+        self.physical[0].cnot(self.physical[2])
+
+
+# This circuit is from https://arxiv.org/pdf/quant-ph/0002039.pdf, page 9. It
+# lets two peers perform a remote CNOT using a single EPR pair.
+@dataclass()
+class RemoteCNOT:
+    """
+    RemoteCNOT teleports qubits, |alpha> and |beta>, through an EPR pair
+    composed of |red> and |blue>. The result of the protocol is that
+        |red>  = |alpha>
+        |blue> = |beta ⊕ alpha>
+    """
+    left: Host
+    right: Host
+
+    def left_protocol(self, alpha: Qubit, red: Qubit):
+        red.cnot(alpha)
+        x = alpha.measure()
+        if x == 1:
+            red.X()
+        self.left.send_classical(self.right.host_id, str(x), await_ack=True)
+
+        z = self.left.get_next_classical(self.right.host_id, wait=-1).content
+        if z == '1':
+            red.Z()
+
+    def right_protocol(self, blue: Qubit, beta: Qubit):
+        beta.cnot(blue)
+        beta.H()
+
+        x = self.right.get_next_classical(self.left.host_id, wait=-1).content
+        if x == '1':
+            blue.X()
+
+        z = beta.measure()
+        self.right.send_classical(self.left.host_id, str(z), await_ack=True)
+        if z == 1:
+            blue.Z()
+
+
+@dataclass()
+class EncodedGenerationProtocol:
+    """
+    EncodedGenerationProtocol establishes an encoded Φ^+ between left and right
+    hosts. This is done as follows.
+
+    1. locally prepare encoded states ⌈|+>⌋ and ⌈|0>⌋
+
+    For each each physical qubit:
+
+    2. left creates an EPR pair
+    3. left distributes half of the EPR pair to right
+    4. peers use the EPR pair to perform a transverse teleportation-based CNOT
+    """
+    left: Host
+    right: Host
+    remote_cnot: RemoteCNOT
+
+    def __init__(self, left, right):
+        self.left = left
+        self.right = right
+        self.remote_cnot = RemoteCNOT(left, right)
+
+    def left_protocol(self, left: Host, n: int):
+        logical = RepetitionCodedQubit(self.left)
+        logical.H()
+
+        for k, physical in enumerate(logical):
+            epr = send_epr(self.left, self.right)
+            self.remote_cnot.left_protocol(physical, epr)
+            self.left.add_qubit(self.left.host_id, epr, f"{n}>{k}")
+
+    def right_protocol(self, right: Host, n: int):
+        # prepare an encoded |0>
+        logical = RepetitionCodedQubit(right)
+
+        for k, physical in enumerate(logical):
+            epr = self.right.get_qubit(self.left.host_id, wait=-1)
+            self.remote_cnot.right_protocol(epr, physical)
+            right.add_qubit(right.host_id, epr, f"{n}<{k}")
+
+    def get_logical_qubit(self, host, n):
+        return (host.get_qubit_by_id(f"{n}>{k}") for k in range(3))
+
+
+def encoded_connection(host: Host, left: Host, right: Host, n: int):
+    ms = []
+    for k in range(3):
+        p = host.get_qubit_by_id(f"{n}>{k}")
+        q = host.get_qubit_by_id(f"{n}<{k}")
+        ms.append(str(Ebit.from_bell_measurement(p, q)))
+    host.send_classical(left.host_id, mode(ms), await_ack=True)
+    host.send_classical(right.host_id, mode(ms), await_ack=True)
+
+
+def pauli_frame_left(host: Host, right: Host, n: int):
+    msg = host.get_next_classical(right.host_id, wait=-1).content
+    for k in range(3):
+        q = host.get_qubit_by_id(f"{n}>{k}")
+        if msg == 'psi+':
+            q.X()
+        elif msg == 'phi-':
+            q.Z()
+
+
+def pauli_frame_right(host: Host, left: Host, n: int):
+    msg = host.get_next_classical(left.host_id, wait=-1).content
+    for k in range(3):
+        q = host.get_qubit_by_id(f"{n}<{k}")
+        if msg == 'psi-':
+            q.Y()
+
+
+def check_correlations(hosts, logical_qubits):
+    print("Alice: ", end='')
+    for n in range(logical_qubits):
+        for k in range(3):
+            p = hosts[0].get_qubit_by_id(f"{n}>{k}")
+            print(f"{p.measure()}", end='')
+    print()
+    print("Bob:   ", end='')
+    for n in range(logical_qubits):
+        for k in range(3):
+            q = hosts[-1].get_qubit_by_id(f"{n}<{k}")
+            print(f"{q.measure()}", end='')
+    print()
+
+
+def new_network(repeaters=2):
+    network = Network.get_instance()
+    peers = ["Alice"] + [f"Polly{k}" for k in range(repeaters)] + ["Bob"]
+    network.delay = 0.1
+    network.x_error_rate = 0.3
+
+    hosts = list(map(lambda x: Host(x), peers))
+
+    for k in range(len(peers)-1):
+        hosts[k].add_connection(hosts[k+1].host_id)
+        hosts[k+1].add_connection(hosts[k].host_id)
+
+    for host in hosts:
+        network.add_host(host)
+        host.start()
+
+    network.start(peers)
+    return network, hosts
+
+
+def main():
+    logical_qubits = 5
+    repeater_nodes = 2
+
+    print(f"Establishing {logical_qubits} logical Φ^+"
+          f" using {repeater_nodes} intermediate repeater nodes")
+
+    network, hosts = new_network(repeater_nodes)
+    egs = [EncodedGenerationProtocol(hosts[i], hosts[i+1])
+           for i in range(len(hosts)-1)]
+
+    for n in range(logical_qubits):
+        # 1. Encoded Generation. Generate one logical Φ^+ between neighbours.
+        ts = []
+        for eg in egs:
+            ts.append(eg.left.run_protocol(eg.left_protocol, (n,)))
+            ts.append(eg.right.run_protocol(eg.right_protocol, (n,)))
+        for t in ts:
+            t.join()
+
+        # Perform the swap synchronously from the left-most repeater. This
+        # creates a sequence like:
+        #    Alice <-> Polly0 <-> Polly1 <-> Bob
+        #    Alice <------------> Polly1 <-> Bob
+        #    Alice <-----------------------> Bob
+        for k in range(len(hosts)-2):
+            a, p, b = hosts[0], hosts[k+1], hosts[k+2]
+
+            # 2. Encoded Connection
+            t1 = p.run_protocol(encoded_connection, (a, b, n,))
+
+            # 3. Establish Pauli Frame
+            t2 = a.run_protocol(pauli_frame_left, (p, n))
+            t3 = b.run_protocol(pauli_frame_right, (p, n))
+            t1.join()
+            t2.join()
+            t3.join()
+
+    # Check that the boundary is correlated!
+    check_correlations(hosts, logical_qubits)
+    network.stop()
+
+
+if __name__ == "__main__":
+    main()