sequence 1.2.0__tar.gz → 1.3.1__tar.gz

{sequence-1.2.0 → sequence-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sequence
-Version: 1.2.0
+Version: 1.3.1
 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.
 Keywords: quantum,network,discrete,event,simulator
 Author: Xiaoliang Wu, Joaquin Chung, Alexander Kolar, Alexander Kiefer, Eugene Wang, Tian Zhong, Rajkumar Kettimuthu, Martin Suchara, Robert Hayek, Ansh Singal, Caitao Zhan
@@ -13,6 +13,7 @@ Requires-Dist: gmpy2>=2.2.2
 Requires-Dist: graphviz>=0.21
 Requires-Dist: ipywidgets>=8.1.8
 Requires-Dist: jupyterlab>=4.5.0
+Requires-Dist: lazy-loader>=0.6
 Requires-Dist: matplotlib>=3.10.7
 Requires-Dist: networkx>=3.6.1
 Requires-Dist: numpy>=2.3.5
@@ -184,6 +185,7 @@ Here is the updated table with the Code column populated:
 | 2025 | V. S. Mai et al. | [Towards Optimal Orders for Entanglement Swapping in Path Graphs: A Greedy Approach](https://arxiv.org/abs/2504.14040) | IEEE QCE | |
 | 2024 | C. Howe et al. | [Towards Scalable Quantum Repeater Networks](https://arxiv.org/abs/2409.08416) | arXiv preprint | |
 | 2024 | X. Wu et al. | [Parallel Simulation of Quantum Networks with Distributed Quantum State Management](https://dl.acm.org/doi/abs/10.1145/3634701) | ACM TOMACS | |
+| 2024 | L. Vinci | [Quantum Key Distribution Performance: Extending the Sequence simulator to Estimate the Speed of free-space Optic Links](https://hdl.handle.net/20.500.14247/17332) | Master's Thesis, Ca’ Foscari University of Venice | [GitHub](https://github.com/lcky00/QKD_Simulator) |
 | 2023 | R. Zhou et al. | [A Simulator of Atom-Atom Entanglement with Atomic Ensembles and Quantum Optics](https://doi.org/10.1109/QCE57702.2023.00143) | IEEE QCE | |
 | 2023 | M.G. Davis et al. | [Towards Distributed Quantum Computing by Qubit and Gate Graph Partitioning Techniques](https://doi.org/10.1109/QCE57702.2023.00026) | IEEE QCE | |
 | 2022 | A. Zang et al. | [Simulation of Entanglement Generation between Absorptive Quantum Memories](https://doi.org/10.1109/QCE53715.2022.00084) | IEEE QCE | |

{sequence-1.2.0 → sequence-1.3.1}/README.md

@@ -148,6 +148,7 @@ Here is the updated table with the Code column populated:
 | 2025 | V. S. Mai et al. | [Towards Optimal Orders for Entanglement Swapping in Path Graphs: A Greedy Approach](https://arxiv.org/abs/2504.14040) | IEEE QCE | |
 | 2024 | C. Howe et al. | [Towards Scalable Quantum Repeater Networks](https://arxiv.org/abs/2409.08416) | arXiv preprint | |
 | 2024 | X. Wu et al. | [Parallel Simulation of Quantum Networks with Distributed Quantum State Management](https://dl.acm.org/doi/abs/10.1145/3634701) | ACM TOMACS | |
+| 2024 | L. Vinci | [Quantum Key Distribution Performance: Extending the Sequence simulator to Estimate the Speed of free-space Optic Links](https://hdl.handle.net/20.500.14247/17332) | Master's Thesis, Ca’ Foscari University of Venice | [GitHub](https://github.com/lcky00/QKD_Simulator) |
 | 2023 | R. Zhou et al. | [A Simulator of Atom-Atom Entanglement with Atomic Ensembles and Quantum Optics](https://doi.org/10.1109/QCE57702.2023.00143) | IEEE QCE | |
 | 2023 | M.G. Davis et al. | [Towards Distributed Quantum Computing by Qubit and Gate Graph Partitioning Techniques](https://doi.org/10.1109/QCE57702.2023.00026) | IEEE QCE | |
 | 2022 | A. Zang et al. | [Simulation of Entanglement Generation between Absorptive Quantum Memories](https://doi.org/10.1109/QCE53715.2022.00084) | IEEE QCE | |

{sequence-1.2.0 → sequence-1.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sequence"
-version = "1.2.0"
+version = "1.3.1"
 license-files = ["LICENSE"]
 description = "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."
 readme = "README.md"
@@ -22,6 +22,7 @@ dependencies = [
     "graphviz>=0.21",
     "ipywidgets>=8.1.8",
     "jupyterlab>=4.5.0",
+    "lazy-loader>=0.6",
     "matplotlib>=3.10.7",
     "networkx>=3.6.1",
     "numpy>=2.3.5",

{sequence-1.2.0 → sequence-1.3.1}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "sequence"
-version = "1.2.0"
+version = "1.3.1"
 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" }
 ]
@@ -23,6 +23,7 @@ dependencies = [
     "graphviz>=0.21",
     "ipywidgets>=8.1.8",
     "jupyterlab>=4.5.0",
+    "lazy-loader>=0.6",
     "matplotlib>=3.10.7",
     "networkx>=3.6.1",
     "numpy>=2.3.5",
@@ -34,7 +35,7 @@ dependencies = [
     "seaborn>=0.13.2",
     "tqdm>=4.67.1",
     "typer>=0.24.1",
-    "stim>=1.15"
+    "stim>=1.15",
 ]
 
 [project.scripts]
@@ -132,4 +133,4 @@ other_allowed_tags = ["chore"]
 
 default_bump_level = 0
 parse_squash_commits = true
-ignore_merge_commits = true
+ignore_merge_commits = true

sequence-1.3.1/sequence/__init__.py

@@ -0,0 +1,33 @@
+"""SeQUeNCe Quantum Network Simulator. Documentation is provided at https://sequence-rtd-tutorial.readthedocs.io/stable/index.html
+
+Example usage:
+    ```
+    import sequence as sq
+    timeline = sq.Timeline()
+    memory = sq.Memory(...)
+    ```
+"""
+
+from pathlib import Path
+
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)
+
+
+def read_version_from_pyproject() -> str:
+    """Read the project version from a source checkout."""
+    pyproject = Path(__file__).resolve().parent.parent / "pyproject.toml"
+    if not pyproject.exists():
+        return "unknown"
+
+    try:
+        import tomllib
+
+        with pyproject.open("rb") as file:
+            return tomllib.load(file)["project"]["version"]
+    except (ImportError, KeyError, OSError, TypeError):
+        return "unknown"
+
+
+__version__ = read_version_from_pyproject()

sequence-1.3.1/sequence/__init__.pyi

@@ -0,0 +1,169 @@
+from . import (
+    app as app,
+    components as components,
+    constants as constants,
+    entanglement_management as entanglement_management,
+    kernel as kernel,
+    network_management as network_management,
+    qkd as qkd,
+    resource_management as resource_management,
+    topology as topology,
+    utils as utils,
+)
+from .app import (
+    App as App,
+    RandomRequestApp as RandomRequestApp,
+    RequestApp as RequestApp,
+    TeleportApp as TeleportApp,
+)
+from .components import (
+    AbsorptiveBSM as AbsorptiveBSM,
+    AbsorptiveMemory as AbsorptiveMemory,
+    BSM as BSM,
+    BeamSplitter as BeamSplitter,
+    Circuit as Circuit,
+    ClassicalChannel as ClassicalChannel,
+    Detector as Detector,
+    DownConversionProtocol as DownConversionProtocol,
+    EmittingProtocol as EmittingProtocol,
+    FiberStretcher as FiberStretcher,
+    FockBeamSplitter as FockBeamSplitter,
+    FockBeamSplitter2 as FockBeamSplitter2,
+    FockDetector as FockDetector,
+    Interferometer as Interferometer,
+    LightSource as LightSource,
+    Memory as Memory,
+    MemoryArray as MemoryArray,
+    MemoryWithRandomCoherenceTime as MemoryWithRandomCoherenceTime,
+    Mirror as Mirror,
+    OpticalChannel as OpticalChannel,
+    Photon as Photon,
+    PolarizationBSM as PolarizationBSM,
+    QSDetector as QSDetector,
+    QSDetectorFockDirect as QSDetectorFockDirect,
+    QSDetectorFockInterference as QSDetectorFockInterference,
+    QSDetectorPolarization as QSDetectorPolarization,
+    QSDetectorTimeBin as QSDetectorTimeBin,
+    QuantumChannel as QuantumChannel,
+    SPDCLens as SPDCLens,
+    SPDCSource as SPDCSource,
+    ShellBSM as ShellBSM,
+    SingleAtomBSM as SingleAtomBSM,
+    SingleHeraldedBSM as SingleHeraldedBSM,
+    Switch as Switch,
+    TimeBinBSM as TimeBinBSM,
+    Transducer as Transducer,
+    Transmon as Transmon,
+    UpConversionProtocol as UpConversionProtocol,
+    make_bsm as make_bsm,
+)
+from .entanglement_management import (
+    BBPSSW_BDS as BBPSSW_BDS,
+    BBPSSWCircuit as BBPSSWCircuit,
+    BBPSSWMessage as BBPSSWMessage,
+    BBPSSWMsgType as BBPSSWMsgType,
+    BarretKokA as BarretKokA,
+    BarretKokB as BarretKokB,
+    DEJMPS_BDS as DEJMPS_BDS,
+    EntanglementGenerationA as EntanglementGenerationA,
+    EntanglementGenerationB as EntanglementGenerationB,
+    EntanglementGenerationMessage as EntanglementGenerationMessage,
+    EntanglementProtocol as EntanglementProtocol,
+    EntanglementSwappingA as EntanglementSwappingA,
+    EntanglementSwappingA_BDS as EntanglementSwappingA_BDS,
+    EntanglementSwappingA_Circuit as EntanglementSwappingA_Circuit,
+    EntanglementSwappingB as EntanglementSwappingB,
+    EntanglementSwappingB_BDS as EntanglementSwappingB_BDS,
+    EntanglementSwappingB_Circuit as EntanglementSwappingB_Circuit,
+    EntanglementSwappingMessage as EntanglementSwappingMessage,
+    GenerationMsgType as GenerationMsgType,
+    PurificationProtocol as PurificationProtocol,
+    SingleHeraldedA as SingleHeraldedA,
+    SingleHeraldedB as SingleHeraldedB,
+    SwappingMsgType as SwappingMsgType,
+    TeleportMessage as TeleportMessage,
+    TeleportMsgType as TeleportMsgType,
+    TeleportProtocol as TeleportProtocol,
+)
+from .kernel import (
+    BellDiagonalState as BellDiagonalState,
+    ClassicalEntity as ClassicalEntity,
+    DensityState as DensityState,
+    Entity as Entity,
+    Event as Event,
+    EventList as EventList,
+    FreeQuantumState as FreeQuantumState,
+    KetState as KetState,
+    Process as Process,
+    QuantumManager as QuantumManager,
+    QuantumManagerBellDiagonal as QuantumManagerBellDiagonal,
+    QuantumManagerDensity as QuantumManagerDensity,
+    QuantumManagerDensityFock as QuantumManagerDensityFock,
+    QuantumManagerKet as QuantumManagerKet,
+    QuantumManagerStabilizer as QuantumManagerStabilizer,
+    StabilizerState as StabilizerState,
+    State as State,
+    Timeline as Timeline,
+)
+from .message import Message as Message
+from .network_management import (
+    DistributedNetworkManager as DistributedNetworkManager,
+    DistributedRoutingProtocol as DistributedRoutingProtocol,
+    ForwardingMessage as ForwardingMessage,
+    ForwardingMessageType as ForwardingMessageType,
+    ForwardingProtocol as ForwardingProtocol,
+    MemoryTimeCard as MemoryTimeCard,
+    NetworkManager as NetworkManager,
+    NetworkManagerMessage as NetworkManagerMessage,
+    NetworkManagerMsgType as NetworkManagerMsgType,
+    QCap as QCap,
+    RSVPMessage as RSVPMessage,
+    RSVPMsgType as RSVPMsgType,
+    RSVPProtocol as RSVPProtocol,
+    Reservation as Reservation,
+    RoutingProtocol as RoutingProtocol,
+    StaticRoutingProtocol as StaticRoutingProtocol,
+)
+from .protocol import Protocol as Protocol, StackProtocol as StackProtocol
+from .qkd import (
+    BB84 as BB84,
+    BB84Message as BB84Message,
+    BB84MsgType as BB84MsgType,
+    Cascade as Cascade,
+    CascadeMessage as CascadeMessage,
+    CascadeMsgType as CascadeMsgType,
+    pair_bb84_protocols as pair_bb84_protocols,
+    pair_cascade_protocols as pair_cascade_protocols,
+)
+from .resource_management import (
+    MemoryInfo as MemoryInfo,
+    MemoryManager as MemoryManager,
+    ResourceManager as ResourceManager,
+    ResourceManagerMessage as ResourceManagerMessage,
+    ResourceManagerMsgType as ResourceManagerMsgType,
+    Rule as Rule,
+    RuleManager as RuleManager,
+)
+from .topology import (
+    BSMNode as BSMNode,
+    ClassicalNode as ClassicalNode,
+    DQCNetTopo as DQCNetTopo,
+    DQCNode as DQCNode,
+    Node as Node,
+    QKDNode as QKDNode,
+    QKDTopo as QKDTopo,
+    QuantumRouter as QuantumRouter,
+    RouterNetTopo as RouterNetTopo,
+    Topology as Topology,
+)
+from .utils import (
+    encoding as encoding,
+    graphs as graphs,
+    log as log,
+    metrics as metrics,
+    nx_converter as nx_converter,
+)
+
+__version__: str
+
+def read_version_from_pyproject() -> str: ...

sequence-1.3.1/sequence/app/__init__.py

@@ -0,0 +1,5 @@
+"""Applications supplied with SeQUeNCe."""
+
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

sequence-1.3.1/sequence/app/__init__.pyi

@@ -0,0 +1,4 @@
+from .app import App as App
+from .random_request import RandomRequestApp as RandomRequestApp
+from .request_app import RequestApp as RequestApp
+from .teleport_app import TeleportApp as TeleportApp

{sequence-1.2.0 → sequence-1.3.1}/sequence/app/request_app.py

@@ -131,20 +131,20 @@ class RequestApp(App):
             info (MemoryInfo): info on the qualified entangled memory.
         """
 
-        if info.state != "ENTANGLED":
+        if info.state != "ENTANGLED" and info.state != "PURIFIED":
             return
 
         if info.index in self.memo_to_reservation:
             reservation = self.memo_to_reservation[info.index]
             valid_fidelity = info.fidelity >= reservation.fidelity
             if info.remote_node == reservation.initiator and valid_fidelity:
-                self.node.resource_manager.update(None, info.memory, "RAW")
                 metrics.record(EventTypes.DELIVERY, self.node.name, fidelity=info.fidelity, **reservation)
+                self.node.resource_manager.update(None, info.memory, "RAW")
             elif info.remote_node == reservation.responder and valid_fidelity:
                 self.memory_counter += 1
+                metrics.record(EventTypes.DELIVERY, self.node.name, fidelity=info.fidelity, **reservation)
                 log.logger.info(f"Successfully generated entanglement. Counter is at {self.memory_counter}.")
                 self.node.resource_manager.update(None, info.memory, "RAW")
-                metrics.record(EventTypes.DELIVERY, self.node.name, fidelity=info.fidelity, **reservation)
 
     def get_throughput(self) -> float:
         warnings.warn("get_throughput is deprecated and will be removed in a future release, "

sequence-1.3.1/sequence/components/__init__.py

@@ -0,0 +1,5 @@
+"""Public hardware components for quantum-network simulations."""
+
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

sequence-1.3.1/sequence/components/__init__.pyi

@@ -0,0 +1,49 @@
+from .beam_splitter import (
+    BeamSplitter as BeamSplitter,
+    FockBeamSplitter as FockBeamSplitter,
+    FockBeamSplitter2 as FockBeamSplitter2,
+)
+from .bsm import (
+    AbsorptiveBSM as AbsorptiveBSM,
+    BSM as BSM,
+    PolarizationBSM as PolarizationBSM,
+    ShellBSM as ShellBSM,
+    SingleAtomBSM as SingleAtomBSM,
+    SingleHeraldedBSM as SingleHeraldedBSM,
+    TimeBinBSM as TimeBinBSM,
+    make_bsm as make_bsm,
+)
+from .circuit import Circuit as Circuit
+from .detector import (
+    Detector as Detector,
+    FockDetector as FockDetector,
+    QSDetector as QSDetector,
+    QSDetectorFockDirect as QSDetectorFockDirect,
+    QSDetectorFockInterference as QSDetectorFockInterference,
+    QSDetectorPolarization as QSDetectorPolarization,
+    QSDetectorTimeBin as QSDetectorTimeBin,
+)
+from .fiber_stretcher import FiberStretcher as FiberStretcher
+from .interferometer import Interferometer as Interferometer
+from .light_source import LightSource as LightSource, SPDCSource as SPDCSource
+from .memory import (
+    AbsorptiveMemory as AbsorptiveMemory,
+    Memory as Memory,
+    MemoryArray as MemoryArray,
+    MemoryWithRandomCoherenceTime as MemoryWithRandomCoherenceTime,
+)
+from .mirror import Mirror as Mirror
+from .optical_channel import (
+    ClassicalChannel as ClassicalChannel,
+    OpticalChannel as OpticalChannel,
+    QuantumChannel as QuantumChannel,
+)
+from .photon import Photon as Photon
+from .spdc_lens import SPDCLens as SPDCLens
+from .switch import Switch as Switch
+from .transducer import (
+    DownConversionProtocol as DownConversionProtocol,
+    Transducer as Transducer,
+    UpConversionProtocol as UpConversionProtocol,
+)
+from .transmon import EmittingProtocol as EmittingProtocol, Transmon as Transmon

{sequence-1.2.0 → sequence-1.3.1}/sequence/components/memory.py

@@ -333,7 +333,10 @@ class Memory(Entity):
     def reset(self) -> None:
         """Method to clear quantum memory.
 
-        Will reset quantum state to |0> and will clear entanglement information.
+        Discard the state from any joint state first, otherwise the remote memories sharing it keep a
+        stale reference to this key and a later operation on them resurrects the discarded qubit.
+        
+        Then reset quantum state to |0> and will clear entanglement information.
 
         Side Effects:
             Will modify internal parameters and quantum state.
@@ -343,6 +346,7 @@ class Memory(Entity):
         self.generation_time = -1
         self.last_update_time = -1
 
+        self.timeline.quantum_manager.discard(self.qstate_key, self.get_generator().random())
         self.timeline.quantum_manager.set([self.qstate_key], [complex(1), complex(0)])
         self.entangled_memory = {'node_id': None, 'memo_id': None}
         if self.expiration_event is not None:
@@ -360,6 +364,7 @@ class Memory(Entity):
             May schedule expiration event.
         """
 
+        self.timeline.quantum_manager.discard(self.qstate_key, self.get_generator().random())
         self.timeline.quantum_manager.set([self.qstate_key], state)
         self.previous_bsm = -1
         self.entangled_memory = {'node_id': None, 'memo_id': None}

sequence-1.3.1/sequence/entanglement_management/__init__.py

@@ -0,0 +1,5 @@
+"""Entanglement generation, purification, swapping, and teleportation."""
+
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

sequence-1.3.1/sequence/entanglement_management/__init__.pyi

@@ -0,0 +1,34 @@
+from .entanglement_protocol import EntanglementProtocol as EntanglementProtocol
+from .generation import (
+    BarretKokA as BarretKokA,
+    BarretKokB as BarretKokB,
+    EntanglementGenerationA as EntanglementGenerationA,
+    EntanglementGenerationB as EntanglementGenerationB,
+    EntanglementGenerationMessage as EntanglementGenerationMessage,
+    GenerationMsgType as GenerationMsgType,
+    SingleHeraldedA as SingleHeraldedA,
+    SingleHeraldedB as SingleHeraldedB,
+)
+from .purification import (
+    BBPSSW_BDS as BBPSSW_BDS,
+    BBPSSWCircuit as BBPSSWCircuit,
+    BBPSSWMessage as BBPSSWMessage,
+    BBPSSWMsgType as BBPSSWMsgType,
+    DEJMPS_BDS as DEJMPS_BDS,
+    PurificationProtocol as PurificationProtocol,
+)
+from .swapping import (
+    EntanglementSwappingA as EntanglementSwappingA,
+    EntanglementSwappingA_BDS as EntanglementSwappingA_BDS,
+    EntanglementSwappingA_Circuit as EntanglementSwappingA_Circuit,
+    EntanglementSwappingB as EntanglementSwappingB,
+    EntanglementSwappingB_BDS as EntanglementSwappingB_BDS,
+    EntanglementSwappingB_Circuit as EntanglementSwappingB_Circuit,
+    EntanglementSwappingMessage as EntanglementSwappingMessage,
+    SwappingMsgType as SwappingMsgType,
+)
+from .teleportation import (
+    TeleportMessage as TeleportMessage,
+    TeleportMsgType as TeleportMsgType,
+    TeleportProtocol as TeleportProtocol
+)

{sequence-1.2.0 → sequence-1.3.1}/sequence/entanglement_management/swapping/swapping_bds.py

@@ -89,13 +89,8 @@ class EntanglementSwappingA_BDS(EntanglementSwappingA):
             # get BDS conditioned on success, fidelity is the first diagonal element
             new_bds = self.swapping_res()
             fidelity = new_bds[0]
-            metrics.record(
-                EventTypes.ES_SUCCESS,
-                self.owner.name,
-                left_node=self.left_node,
-                right_node=self.right_node,
-                fidelity=fidelity,
-            )
+            metrics.record(EventTypes.ES_SUCCESS, self.owner.name, left_node=self.left_node, 
+                           right_node=self.right_node, fidelity=fidelity)
             keys = [left_remote_memory.qstate_key, right_remote_memory.qstate_key]
             self.owner.timeline.quantum_manager.set(keys, new_bds)
 
@@ -115,12 +110,7 @@ class EntanglementSwappingA_BDS(EntanglementSwappingA):
                                                 meas_res=[])
         else:
             log.logger.info(f'{self.owner.name} Swapping failed!')
-            metrics.record(
-                EventTypes.ES_FAILURE,
-                self.owner.name,
-                left_node=self.left_node,
-                right_node=self.right_node,
-            )
+            metrics.record(EventTypes.ES_FAILURE, self.owner.name, left_node=self.left_node, right_node=self.right_node)
             msg_l = EntanglementSwappingMessage(SwappingMsgType.SWAP_RES, self.left_protocol_name, fidelity=0)
             msg_r = EntanglementSwappingMessage(SwappingMsgType.SWAP_RES, self.right_protocol_name, fidelity=0)
 

{sequence-1.2.0 → sequence-1.3.1}/sequence/entanglement_management/swapping/swapping_circuit.py

@@ -85,13 +85,8 @@ class EntanglementSwappingA_Circuit(EntanglementSwappingA):
         if self.owner.get_generator().random() < self.success_probability():
             # swapping succeeded
             fidelity = self.updated_fidelity(self.left_memo.fidelity, self.right_memo.fidelity)
-            metrics.record(
-                EventTypes.ES_SUCCESS,
-                self.owner.name,
-                left_node=self.left_node,
-                right_node=self.right_node,
-                fidelity=fidelity,
-            )
+            metrics.record(EventTypes.ES_SUCCESS, self.owner.name, left_node=self.left_node, 
+                           right_node=self.right_node, fidelity=fidelity)
             self.is_success = True
 
             expire_time = min(self.left_memo.get_expire_time(), self.right_memo.get_expire_time())
@@ -116,12 +111,7 @@ class EntanglementSwappingA_Circuit(EntanglementSwappingA):
         else:
             # swapping failed
             log.logger.info(f"{self.name} swapping failed")
-            metrics.record(
-                EventTypes.ES_FAILURE,
-                self.owner.name,
-                left_node=self.left_node,
-                right_node=self.right_node,
-            )
+            metrics.record(EventTypes.ES_FAILURE, self.owner.name, left_node=self.left_node, right_node=self.right_node)
             msg_l = EntanglementSwappingMessage(SwappingMsgType.SWAP_RES,self.left_protocol_name, fidelity=0)
             msg_r = EntanglementSwappingMessage(SwappingMsgType.SWAP_RES, self.right_protocol_name, fidelity=0)
 

sequence-1.3.1/sequence/kernel/__init__.py

@@ -0,0 +1,5 @@
+"""Core simulation primitives and quantum-state management."""
+
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)

sequence-1.3.1/sequence/kernel/__init__.pyi

@@ -0,0 +1,21 @@
+from .entity import ClassicalEntity as ClassicalEntity, Entity as Entity
+from .event import Event as Event
+from .eventlist import EventList as EventList
+from .process import Process as Process
+from .quantum_manager import (
+    QuantumManager as QuantumManager,
+    QuantumManagerBellDiagonal as QuantumManagerBellDiagonal,
+    QuantumManagerDensity as QuantumManagerDensity,
+    QuantumManagerDensityFock as QuantumManagerDensityFock,
+    QuantumManagerKet as QuantumManagerKet,
+    QuantumManagerStabilizer as QuantumManagerStabilizer,
+)
+from .quantum_state import (
+    BellDiagonalState as BellDiagonalState,
+    DensityState as DensityState,
+    FreeQuantumState as FreeQuantumState,
+    KetState as KetState,
+    StabilizerState as StabilizerState,
+    State as State,
+)
+from .timeline import Timeline as Timeline

{sequence-1.2.0 → sequence-1.3.1}/sequence/kernel/quantum_manager/base.py

@@ -125,7 +125,23 @@ class QuantumManager(ABC):
             keys (list[int]): key(s) of state(s) to change.
             state (Any): State payload to assign, type determined by type of subclass.
         """
+        pass
+
+    @abstractmethod
+    def discard(self, key: int, meas_samp: float | None = None) -> None:
+        """Discard a key from any joint quantum state while updating the remaining subsystem according to the 
+        quantum formalism. Discarding a subsystem of the quantum state.
 
+        `set` only rebinds the keys it is given. When a key that belongs to a multi-qubit
+        state is rebound on its own, the remaining keys keep a stale reference to it and a
+        later operation on any of them will silently pull the discarded key back in.
+        Formalisms that group keys into a shared state object must override this method to
+        remove `key` from its group before the caller rebinds it.
+
+        Args:
+            key (int): key to discard from its joint state.
+            meas_samp (float | None): random sample in [0, 1) used if discarding requires a collapse.
+        """
         pass
 
     def remove(self, key: int) -> None:

{sequence-1.2.0 → sequence-1.3.1}/sequence/kernel/quantum_manager/bell_diagonal.py

@@ -64,3 +64,19 @@ class QuantumManagerBellDiagonal(QuantumManager):
 
     def set_to_noiseless(self, keys: list[int]):
         self.set(keys, [float(1), float(0), float(0), float(0)])
+
+    def discard(self, key: int, meas_samp: float | None = None) -> None:
+        """Discard a quantum state from the manager.
+
+        Note:
+            `meas_samp` is intentionally unused in the Bell diagonal formalism. Kept for interface compatibility.
+
+        Args:
+            key (int): key to discard from the quantum manager.
+            meas_samp (float | None): unused.
+        """
+        state = self.states.get(key)
+        if state is None:
+            return
+        if key in state.keys:
+            self.states.pop(key)

{sequence-1.2.0 → sequence-1.3.1}/sequence/kernel/quantum_manager/density_matrix.py

@@ -132,6 +132,33 @@ class QuantumManagerDensity(QuantumManager):
         """
         self.set([key], [[complex(0), complex(0)], [complex(0), complex(1)]])
 
+    def discard(self, key: int, meas_samp: float | None = None) -> None:
+        """Discard a key from its joint state by tracing it out.
+
+        A density matrix represents the reduced state of the remaining qubits exactly,
+        so no collapse is needed here.
+
+        Note:
+            `meas_samp` is intentionally unused in the density matrix formalism. Kept for interface compatibility.
+
+        Args:
+            key (int): key to detach from its joint state.
+            meas_samp (float | None): unused.
+        """
+        state = self.states.get(key)
+        if state is None or len(state.keys) <= 1:
+            return
+
+        all_keys = state.keys
+        index = all_keys.index(key)
+        num_qubits = len(all_keys)
+        tensor = np.asarray(state.state, dtype=complex).reshape((2,) * (2 * num_qubits))
+        reduced = np.trace(tensor, axis1=index, axis2=num_qubits + index)
+        reduced = reduced.reshape(2 ** (num_qubits - 1), 2 ** (num_qubits - 1))
+
+        rem_keys = [k for k in all_keys if k != key]
+        self.set(rem_keys, reduced)
+
     def get_ascending_keys(self, key: int) -> DensityState:
         """Method to get quantum state stored at an index.
            Reorders qubits (in-place) in ascending order of keys before returning.

{sequence-1.2.0 → sequence-1.3.1}/sequence/kernel/quantum_manager/fock_density_matrix.py

@@ -312,3 +312,6 @@ class QuantumManagerDensityFock(QuantumManager):
             output_state += kraus_op @ prepared_state @ kraus_op.conj().T
 
         self.set(all_keys, output_state)
+
+    def discard(self, key: int, meas_samp: float | None = None) -> None:
+        raise NotImplementedError("discard() is not implemented for QuantumManagerDensityFock")

{sequence-1.2.0 → sequence-1.3.1}/sequence/kernel/quantum_manager/ket_vector.py

@@ -131,6 +131,24 @@ class QuantumManagerKet(QuantumManager):
         for key in keys:
             self.states[key] = new_state
 
+    def discard(self, key: int, meas_samp: float | None = None) -> None:
+        """Discard a key from its joint state by collapsing it in the computational basis.
+
+        A ket vector cannot represent the mixed state left on the other qubits by simply
+        discarding one of them, so the discarded qubit is measured. The remaining keys
+        receive the normalized post-measurement branch and no longer reference `key`.
+
+        Args:
+            key (int): key to discard from its joint state.
+            meas_samp (float | None): random sample in [0, 1) selecting the collapse outcome.
+        """
+        state = self.states.get(key)
+        if state is None or len(state.keys) <= 1:
+            return
+        if meas_samp is None:
+            raise ValueError("meas_samp is required to separate a key from a joint state.")
+        self._measure(state.state, [key], state.keys, meas_samp)
+
     def get_ascending_keys(self, key: int) -> KetState:
         """Method to get quantum state stored at an index.
            Reorders qubits (in-place) in ascending order of keys before returning.