QNetEngine

Main simulation engine — the entry point for all entanglement distribution, protocol, and Monte Carlo simulations.

Constructor

QNetEngine(config: Optional[SimulationConfig] = None)

Parameter	Type	Default	Description
config	SimulationConfig	None	Optional simulation timeline configuration; uses defaults when omitted

Methods

define_network(nodes, links)

Set or replace the network topology.

def define_network(nodes: List[NodeDefinition], links: List[LinkDefinition]) -> None

Parameter	Type	Description
nodes	List[NodeDefinition]	Node definitions for the network
links	List[LinkDefinition]	Link definitions connecting nodes

request_entanglement(from_node, to, fidelity_target, max_latency_ms, strategy=None)

Run a single entanglement distribution simulation.

def request_entanglement(
    from_node: str,
    to: str,
    fidelity_target: float,
    max_latency_ms: float,
    strategy: Optional[StrategyType] = None,
) -> SimulationResult

Parameter	Type	Default	Description
from_node	str	—	Source node ID
to	str	—	Destination node ID
fidelity_target	float	—	Required entanglement fidelity
max_latency_ms	float	—	Maximum allowed latency (ms)
strategy	StrategyType	None	Routing strategy; uses default when omitted

Returns: SimulationResult

simulate(from_node, to, fidelity_target, max_latency_ms, runs, strategy=None)

Run a Monte Carlo ensemble of entanglement distribution simulations.

def simulate(
    from_node: str,
    to: str,
    fidelity_target: float,
    max_latency_ms: float,
    runs: int,
    strategy: Optional[StrategyType] = None,
) -> MonteCarloStats

Parameter	Type	Default	Description
from_node	str	—	Source node ID
to	str	—	Destination node ID
fidelity_target	float	—	Required entanglement fidelity
max_latency_ms	float	—	Maximum allowed latency (ms)
runs	int	—	Number of simulation runs
strategy	StrategyType	None	Routing strategy; uses default when omitted

Returns: MonteCarloStats

run_qkd(params)

Run a BB84-style quantum key distribution protocol.

def run_qkd(params: QKDParameters) -> QKDResult

Parameter	Type	Description
params	QKDParameters	QKD protocol parameters

Returns: QKDResult

Note: Monte Carlo ensemble for QKD is planned but not yet implemented.

execute_teleportation(params)

Execute entanglement-based quantum state teleportation across the network.

def execute_teleportation(params: TeleportationParameters) -> TeleportationOutcome

Parameter	Type	Description
params	TeleportationParameters	Teleportation protocol parameters

Returns: TeleportationOutcome

Note: Monte Carlo ensemble for teleportation is planned but not yet implemented.

run_distributed_computation(participants, coordination_topology, measurement_basis, classical_relay_latency_ms=None)

Run a distributed quantum computing protocol with coordinated measurements.

def run_distributed_computation(
    participants: List[str],
    coordination_topology: CoordinationTopology,
    measurement_basis: MeasurementBasis,
    classical_relay_latency_ms: Optional[float] = None,
) -> DistributedComputingResult

Parameter	Type	Default	Description
participants	List[str]	—	Participant node IDs
coordination_topology	CoordinationTopology	—	Coordination pattern (star/ring/mesh/arbitrary)
measurement_basis	MeasurementBasis	GHZ, 0.85	Measurement basis config
classical_relay_latency_ms	float	None	Classical relay latency (ms)

Returns: DistributedComputingResult

Note: Monte Carlo ensemble for distributed computation is planned but not yet implemented.