sequence 0.8.1.dev229865249__tar.gz → 0.8.2__tar.gz

{sequence-0.8.1.dev229865249/sequence.egg-info → sequence-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sequence
-Version: 0.8.1.dev229865249
+Version: 0.8.2
 Summary: Simulator of QUantum Network Communication (SeQUeNCe) is an open-source tool that allows modeling of quantum networks including photonic network components, control protocols, and applications.
 Author-email: "Xiaoliang Wu, Joaquin Chung, Alexander Kolar, Alexander Kiefer, Eugene Wang, Tian Zhong, Rajkumar Kettimuthu, Martin Suchara, Robert Hayek, Ansh Singal, Caitao Zhan" <czhan@anl.gov>
 Maintainer-email: Caitao Zhan <czhan@anl.gov>
@@ -75,7 +75,7 @@ SeQUeNCe is an open source, discrete-event simulator for quantum networks. As de
 These modules can be edited by users to define additional functionality and test protocol schemes, or may be used as-is to test network parameters and topologies.
 
 ## Installing
-SeQUeNCe requires [Python](https://www.python.org/downloads/) 3.10 or later. You can simply install SeQUeNCe using `pip`:
+SeQUeNCe requires [Python](https://www.python.org/downloads/) 3.11 or later. You can simply install SeQUeNCe using `pip`:
 ```
 pip install sequence
 ```
@@ -116,16 +116,7 @@ python gui.py
 ```
 
 ## Usage Examples
-Many examples of SeQUeNCe in action can be found in the [example](/example) folder. These include both quantum key distribution and entanglement distribution examples.
-
-### Starlight Experiments
-Code for the experiments performed in our paper can be found in the file `starlight_experiments.py`. This script uses the `starlight.json` file (also within the example folder) to specify the network topology.
-
-### Jupyter Notebook Examples
-The example folder contains several scripts that can be run with jupyter notebook for easy editing and visualization. These examples include:
-* `BB84_eg.ipynb`, which uses the BB84 protocol to distribute secure keys between two quantum nodes
-* `two_node_eg.ipynb`, which performs entanglement generation between two adjacent quantum routers
-* `three_node_eg_ep_es.ipynb`, which performs entanglement generation, purification, and swapping for a linear network of three quantum routers
+Many examples of SeQUeNCe in action can be found in the [example](/example) folder. The example includes jupyter notebook demos, and code used in published papers.
 
 ## Additional Tools
 

{sequence-0.8.1.dev229865249 → sequence-0.8.2}/README.md

@@ -37,7 +37,7 @@ SeQUeNCe is an open source, discrete-event simulator for quantum networks. As de
 These modules can be edited by users to define additional functionality and test protocol schemes, or may be used as-is to test network parameters and topologies.
 
 ## Installing
-SeQUeNCe requires [Python](https://www.python.org/downloads/) 3.10 or later. You can simply install SeQUeNCe using `pip`:
+SeQUeNCe requires [Python](https://www.python.org/downloads/) 3.11 or later. You can simply install SeQUeNCe using `pip`:
 ```
 pip install sequence
 ```
@@ -78,16 +78,7 @@ python gui.py
 ```
 
 ## Usage Examples
-Many examples of SeQUeNCe in action can be found in the [example](/example) folder. These include both quantum key distribution and entanglement distribution examples.
-
-### Starlight Experiments
-Code for the experiments performed in our paper can be found in the file `starlight_experiments.py`. This script uses the `starlight.json` file (also within the example folder) to specify the network topology.
-
-### Jupyter Notebook Examples
-The example folder contains several scripts that can be run with jupyter notebook for easy editing and visualization. These examples include:
-* `BB84_eg.ipynb`, which uses the BB84 protocol to distribute secure keys between two quantum nodes
-* `two_node_eg.ipynb`, which performs entanglement generation between two adjacent quantum routers
-* `three_node_eg_ep_es.ipynb`, which performs entanglement generation, purification, and swapping for a linear network of three quantum routers
+Many examples of SeQUeNCe in action can be found in the [example](/example) folder. The example includes jupyter notebook demos, and code used in published papers.
 
 ## Additional Tools
 

{sequence-0.8.1.dev229865249 → sequence-0.8.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sequence"
-version = "0.8.1.dev229865249"
+version = "0.8.2"
 authors = [
     { name = "Xiaoliang Wu, Joaquin Chung, Alexander Kolar, Alexander Kiefer, Eugene Wang, Tian Zhong, Rajkumar Kettimuthu, Martin Suchara, Robert Hayek, Ansh Singal, Caitao Zhan", email = "czhan@anl.gov" }
 ]
@@ -13,7 +13,7 @@ requires-python = ">=3.11, <3.14"
 classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
-    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.13"
 ]
 dynamic = ["dependencies"]
 keywords = ["quantum", "network", "discrete", "event", "simulator"]

{sequence-0.8.1.dev229865249 → sequence-0.8.2}/sequence/__init__.py

@@ -1,7 +1,7 @@
 __all__ = ['app', 'components', 'entanglement_management', 'kernel', 'network_management', 'qkd', 'resource_management',
            'topology', 'utils', 'message', 'protocol', 'gui', 'qlan']
 
-__version__ = '0.8.1'
+__version__ = '0.8.2'
 
 def __dir__():
     return sorted(__all__)

{sequence-0.8.1.dev229865249 → sequence-0.8.2}/sequence/app/request_app.py

@@ -161,4 +161,4 @@ class RequestApp:
         self.name = name
 
     def __str__(self) -> str:
-        return self.name
+        return self.name

{sequence-0.8.1.dev229865249 → sequence-0.8.2}/sequence/components/detector.py

@@ -11,6 +11,7 @@ from typing import TYPE_CHECKING, Any
 from numpy import eye, kron, exp, sqrt
 from scipy.linalg import fractional_matrix_power
 from math import factorial
+import gmpy2
 
 if TYPE_CHECKING:
     from ..kernel.timeline import Timeline
@@ -26,6 +27,9 @@ from ..kernel.process import Process
 from ..utils.encoding import time_bin, fock
 from ..utils import log
 
+gmpy2.get_context().precision = 80  # 80 bits ~ 24 decimal digits ~ sufficient for 10,000 years of ps timing 
+from gmpy2 import mpfr, rint, ceil
+
 
 class Detector(Entity):
     """Single photon detector device.
@@ -40,6 +44,7 @@ class Detector(Entity):
         dark_count (float): average number of false positive detections per second.
         count_rate (float): maximum detection rate; defines detector cooldown time.
         time_resolution (int): minimum resolving power of photon arrival time (in ps).
+        next_detection_time (int): time of next possible detection event.
         photon_counter (int): counts number of detection events.
     """
 
@@ -119,9 +124,11 @@ class Detector(Entity):
         now = self.timeline.now()
 
         if now > self.next_detection_time:
-            time = round(now / self.time_resolution) * self.time_resolution
+            index = rint(mpfr(now) / mpfr(self.time_resolution))
+            time = int(index) * self.time_resolution
             self.notify({'time': time})
-            self.next_detection_time = now + (1e12 / self.count_rate)  # period in ps
+            period = int(ceil(mpfr("1e12") / mpfr(self.count_rate))) # period in ps
+            self.next_detection_time = now + period
 
     def notify(self, info: dict[str, Any]):
         """Custom notify function (calls `trigger` method)."""

{sequence-0.8.1.dev229865249 → sequence-0.8.2}/sequence/components/memory.py

@@ -312,7 +312,7 @@ class Memory(Entity):
             Will notify upper entities of expiration via the `pop` interface.
             Will modify the quantum state of the memory.
         """
-
+        #log.logger.debug(f'Memory {self.name} has expired at time {self.timeline.now()}')
         if self.is_in_application:
             pass
 
@@ -411,6 +411,7 @@ class Memory(Entity):
             self.timeline.remove_event(self.expiration_event)
 
         decay_time = self.timeline.now() + int(self.cutoff_ratio * self.coherence_time * 1e12)
+        #log.logger.debug(f'Memory {self.name} is set to expire at time {decay_time}')
         process = Process(self, "expire", [])
         event = Event(decay_time, process)
         self.timeline.schedule(event)
@@ -425,7 +426,7 @@ class Memory(Entity):
         Args:
             time (int): new expiration time.
         """
-
+        #log.logger.debug(f'Memory expiry is updated')
         time = max(time, self.timeline.now())
         if self.expiration_event is None:
             if time >= self.timeline.now():

{sequence-0.8.1.dev229865249 → sequence-0.8.2}/sequence/components/optical_channel.py

@@ -21,7 +21,7 @@ from ..kernel.process import Process
 from ..utils import log
 from ..constants import SPEED_OF_LIGHT, MICROSECOND, SECOND, EPSILON
 
-gmpy2.get_context().precision = 200
+gmpy2.get_context().precision = 80 # 80 bits ~ 24 decimal digits ~ sufficient for 10,000 years of ps timing 
 EPSILON_MPFR = gmpy2.mpfr(EPSILON)
 PS_PER_SECOND = gmpy2.mpz(SECOND)
 
@@ -143,7 +143,7 @@ class QuantumChannel(OpticalChannel):
         log.logger.info("{} send qubit with state {} to {} by Channel {}".format(
                         self.sender.name, qubit.quantum_state, self.receiver, self.name))
 
-        assert self.delay >= 0 and self.loss < 1, f"QuantumChannel init() function has not been run for {self.name}"
+        assert self.delay >= 0 and self.loss <= 1, f"QuantumChannel init() function has not been run for {self.name}"
         assert source == self.sender
 
         # remove lowest time bin

{sequence-0.8.1.dev229865249 → sequence-0.8.2}/sequence/entanglement_management/generation/single_heralded.py

@@ -86,9 +86,9 @@ class SingleHeraldedA(EntanglementGenerationA, QuantumCircuitMixin):
 
                 self._entanglement_succeed()
 
-        else:
-            self._entanglement_fail()
-            return False
+            else:
+                self._entanglement_fail()
+                return False
 
         return True
 
@@ -169,7 +169,8 @@ class SingleHeraldedA(EntanglementGenerationA, QuantumCircuitMixin):
                 process = Process(self, "start", [])  # for the second round
             else:
                 process = Process(self, "update_memory", [])
-            event = Event(future_start_time, process)
+            priority = self.owner.timeline.schedule_counter
+            event = Event(future_start_time, process, priority)
             self.owner.timeline.schedule(event)
             self.scheduled_events.append(event)
 
@@ -198,7 +199,8 @@ class SingleHeraldedA(EntanglementGenerationA, QuantumCircuitMixin):
                 process = Process(self, "start", [])  # for the second round
             else:
                 process = Process(self, "update_memory", [])
-            event = Event(future_start_time, process)
+            priority = self.owner.timeline.schedule_counter
+            event = Event(future_start_time, process, priority)
             self.owner.timeline.schedule(event)
             self.scheduled_events.append(event)
 

{sequence-0.8.1.dev229865249 → sequence-0.8.2}/sequence/entanglement_management/purification/bbpssw_bds.py

@@ -4,12 +4,13 @@ This module defines code to support the BBPSSW protocol for entanglement purific
 Success results are pre-determined based on network parameters.
 Also defined is the message type used by the BBPSSW code.
 """
+from __future__ import annotations
 
 from typing import List, Tuple
 from typing import TYPE_CHECKING
 
 import numpy as np
-
+import numpy.typing as npt
 
 if TYPE_CHECKING:
     from ...components.memory import Memory
@@ -39,7 +40,7 @@ class BBPSSW_BDS(BBPSSWProtocol):
         is_twirled (bool): whether we twirl the input and output BDS. True: BBPSSW, False: DEJMPS. (default True)
     """
 
-    def __init__(self, owner: "Node", name: str, kept_memo: "Memory", meas_memo: "Memory", is_twirled=True):
+    def __init__(self, owner: Node, name: str, kept_memo: Memory, meas_memo: Memory, is_twirled=True):
         """Constructor for purification protocol.
 
         args:
@@ -53,6 +54,7 @@ class BBPSSW_BDS(BBPSSWProtocol):
 
         self.is_twirled = is_twirled
         self.ep_matched = False
+        self.protocol_type = 'bbpssw_bds'
 
     def start(self) -> None:
         """Method to start entanglement purification.
@@ -109,7 +111,8 @@ class BBPSSW_BDS(BBPSSWProtocol):
             keys = [self.kept_memo.qstate_key, remote_kept_memo.qstate_key]
             self.owner.timeline.quantum_manager.set(keys, new_bds)
 
-        message = BBPSSWMessage(BBPSSWMsgType.PURIFICATION_RES, self.remote_protocol_name, meas_res=self.meas_res)
+        log.logger.debug(f'Starting BBPSSW from {self.owner} to {self.remote_node_name}')
+        message = BBPSSWMessage(BBPSSWMsgType.PURIFICATION_RES, self.remote_protocol_name, meas_res=self.meas_res, protocol_type=self.protocol_type)
         self.owner.send_message(self.remote_node_name, message)
 
     def received_message(self, src: str, msg: BBPSSWMessage) -> None:
@@ -122,18 +125,9 @@ class BBPSSW_BDS(BBPSSWProtocol):
         Side Effects:
             Will call `update_resource_manager` method.
         """
-
-        # check the status of entanglement
-        if self.meas_memo.entangled_memory['node_id'] is None or self.kept_memo.entangled_memory['node_id'] is None:
-            log.logger.info(f'No entanglement for {self.meas_memo} or {self.kept_memo}.')
-            # when the AC Protocol expires, the purification protocol on the primary node will get removed, but the purification protocol on the non-primary node is still there
-            self.owner.protocols.remove(self)
-            return
-
         if msg.msg_type == BBPSSWMsgType.PURIFICATION_RES:
-
             purification_success = (self.meas_res == msg.meas_res)
-            log.logger.info(self.owner.name + f" received result message, succeeded={purification_success}")
+            log.logger.info(self.owner.name + f'received result message, succeeded={purification_success}')
             assert src == self.remote_node_name
 
             self.update_resource_manager(self.meas_memo, "RAW")
@@ -145,7 +139,7 @@ class BBPSSW_BDS(BBPSSWProtocol):
                 remote_kept_memory.bds_decohere()
                 self.kept_memo.bds_decohere()
                 self.kept_memo.fidelity = self.kept_memo.get_bds_fidelity()
-                self.update_resource_manager(self.kept_memo, state="ENTANGLED")
+                self.update_resource_manager(self.kept_memo, state="PURIFIED")
             else:
                 log.logger.info(f'Purification failed because measure results: {self.meas_res}, {msg.meas_res}')
                 self.update_resource_manager(self.kept_memo, state="RAW")
@@ -153,8 +147,8 @@ class BBPSSW_BDS(BBPSSWProtocol):
         else:
             raise Exception(f'{msg.msg_type} unknown')
 
-    def purification_res(self) -> tuple[float, np.array]:
-        """Method to calculate the correct success probabilty of a purification trial with BDS input.
+    def purification_res(self) -> tuple[float, npt.NDArray]:
+        """Method to calculate the correct success probability of a purification trial with BDS input.
 
         The four BDS density matrix elements of kept entangled pair conditioned on successful purification.
 

{sequence-0.8.1.dev229865249 → sequence-0.8.2}/sequence/entanglement_management/purification/bbpssw_circuit.py

@@ -4,7 +4,7 @@ This module defines code to support the BBPSSW protocol for entanglement purific
 Success results are pre-determined based on network parameters.
 Also defined is the message type used by the BBPSSW code.
 """
-
+from __future__ import annotations
 from functools import lru_cache
 from typing import TYPE_CHECKING
 
@@ -44,7 +44,7 @@ class BBPSSWCircuit(BBPSSWProtocol):
     circuit.cx(0, 1)
     circuit.measure(1)
 
-    def __init__(self, owner: "Node", name: str, kept_memo: "Memory", meas_memo: "Memory"):
+    def __init__(self, owner: Node, name: str, kept_memo: Memory, meas_memo: Memory):
         """Constructor for purification protocol.
 
         args:
@@ -117,7 +117,7 @@ class BBPSSWCircuit(BBPSSWProtocol):
         self.update_resource_manager(self.meas_memo, "RAW")
         if self.meas_res == msg.meas_res:
             self.kept_memo.fidelity = self.improved_fidelity(self.kept_memo.fidelity)
-            self.update_resource_manager(self.kept_memo, state="ENTANGLED")
+            self.update_resource_manager(self.kept_memo, state="PURIFIED")
         else:
             self.update_resource_manager(self.kept_memo, state="RAW")
 

{sequence-0.8.1.dev229865249 → sequence-0.8.2}/sequence/entanglement_management/purification/bbpssw_protocol.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from abc import ABC, abstractmethod
 from enum import Enum, auto
 from typing import TYPE_CHECKING, List, Dict, Type, Optional
@@ -29,9 +30,10 @@ class BBPSSWMessage(Message):
         receiver (str): name of destination protocol instance.
     """
 
-    def __init__(self, msg_type: BBPSSWMsgType, receiver: str, meas_res: int, **kwargs):
+    def __init__(self, msg_type: BBPSSWMsgType, receiver: str, meas_res: int, protocol_type: str='bbpssw'):
         super().__init__(msg_type, receiver)
         self.meas_res = meas_res
+        self.protocol_type = protocol_type
 
     def __str__(self):
         return f"\"BBPSSW: type={self.msg_type}, meas_res={self.meas_res}\""
@@ -41,7 +43,7 @@ class BBPSSWProtocol(EntanglementProtocol, ABC):
     _registry: dict[str, type['BBPSSWProtocol']] = {}
     _global_formalism: str = KET_STATE_FORMALISM
 
-    def __init__(self, owner: "Node", name: str, kept_memo: "Memory", meas_memo: "Memory", **kwargs):
+    def __init__(self, owner: Node, name: str, kept_memo: Memory, meas_memo: Memory, **kwargs):
         """Constructor for purification protocol.
 
         args:
@@ -58,6 +60,7 @@ class BBPSSWProtocol(EntanglementProtocol, ABC):
         self.remote_node_name: str = ''
         self.remote_protocol_name: str = ''
         self.remote_memories: list[str] = []
+        self.protocol_type = 'bbpssw'
         self.meas_res = None
         if self.meas_memo is None:
             self.memories.pop()

{sequence-0.8.1.dev229865249 → sequence-0.8.2}/sequence/entanglement_management/swapping.py

@@ -141,7 +141,7 @@ class EntanglementSwappingA(EntanglementProtocol):
         elif node == self.right_memo.entangled_memory["node_id"]:
             self.right_protocol_name = protocol
         else:
-            raise Exception("Cannot pair protocol {} with {}".format(self.name, protocol))
+            raise Exception(f"Cannot pair protocol {self.name} with {protocol}")
 
     def start(self) -> None:
         """Method to start entanglement swapping protocol.

{sequence-0.8.1.dev229865249 → sequence-0.8.2}/sequence/kernel/process.py

@@ -12,6 +12,7 @@ class Process:
 
     Attributes:
         owner (Any): the object of process.
+        number (int): the process number.
         activation (str): the function name of object.
         activation_args  (list[Any]): the (non-keyword) arguments of object's function.
         activation_kwargs (dict[Any, Any]): the keyword arguments of object's function.
@@ -19,6 +20,7 @@ class Process:
 
     def __init__(self, owner: Any, activation_method: str, activation_args: list[Any], activation_kwargs: dict[Any, Any] = {}):
         self.owner = owner
+        self.number = None
         self.activation = activation_method
         self.activation_args = activation_args
         self.activation_kwargs = activation_kwargs