Trajectree 0.0.2__tar.gz → 0.0.4__tar.gz

{trajectree-0.0.2 → trajectree-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Trajectree
-Version: 0.0.2
+Version: 0.0.4
 Summary: Trajectree is a quantum trajectory theory and tensor network based quantum optics simulator.
 Author-email: Ansh Singal <asingal@u.northwestern.edu>
 License-Expression: MIT

{trajectree-0.0.2 → trajectree-0.0.4}/Trajectree.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Trajectree
-Version: 0.0.2
+Version: 0.0.4
 Summary: Trajectree is a quantum trajectory theory and tensor network based quantum optics simulator.
 Author-email: Ansh Singal <asingal@u.northwestern.edu>
 License-Expression: MIT

{trajectree-0.0.2 → trajectree-0.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "Trajectree"
-version = "0.0.2"
+version = "0.0.4"
 authors = [{ name="Ansh Singal", email="asingal@u.northwestern.edu" },]
 description = "Trajectree is a quantum trajectory theory and tensor network based quantum optics simulator."
 readme = "README.md"

{trajectree-0.0.2 → trajectree-0.0.4}/trajectree/fock_optics/measurement.py

@@ -127,26 +127,26 @@ def bell_state_measurement(psi, N, site_tags, num_modes, efficiencies, dark_coun
     if return_MPOs:
         returned_MPOs = [U_BS_H, U_BS_V]
         if use_trajectory:
-            quantum_channel_list = [quantum_channel(N = N, num_modes = num_modes, formalism = "closed", unitary_MPOs = BSM_MPO, name = "BSM") for BSM_MPO in returned_MPOs]
+            quantum_channel_list = [quantum_channel(N = N, num_modes = num_modes, formalism = "closed", unitary_MPOs = BSM_MPO, name = "beam splitter") for BSM_MPO in returned_MPOs]
 
             damping_kraus_ops_0 = single_mode_bosonic_noise_channels(noise_parameter = 1-efficiencies[0], N = N)
             damping_kraus_ops_1 = single_mode_bosonic_noise_channels(noise_parameter = 1-efficiencies[1], N = N)
             two_mode_kraus_ops_0 = [sp.kron(op1, op2) for op1 in damping_kraus_ops_0 for op2 in damping_kraus_ops_0]
             two_mode_kraus_ops_1 = [sp.kron(op1, op2) for op1 in damping_kraus_ops_1 for op2 in damping_kraus_ops_1]
-            quantum_channel_list.append(quantum_channel(N = N, num_modes = num_modes, formalism = "kraus", kraus_ops_tuple = ((2,3), two_mode_kraus_ops_0))) # The tuples in this list are defined as (sites, kraus_ops). The sites are the sites where the Kraus ops are applied.
-            quantum_channel_list.append(quantum_channel(N = N, num_modes = num_modes, formalism = "kraus", kraus_ops_tuple = ((6,7), two_mode_kraus_ops_1))) # The tuples in this list are defined as (sites, kraus_ops). The sites are the sites where the Kraus ops are applied.
+            quantum_channel_list.append(quantum_channel(N = N, num_modes = num_modes, formalism = "kraus", kraus_ops_tuple = ((2,3), two_mode_kraus_ops_0), name = "detector inefficiency")) # The tuples in this list are defined as (sites, kraus_ops). The sites are the sites where the Kraus ops are applied.
+            quantum_channel_list.append(quantum_channel(N = N, num_modes = num_modes, formalism = "kraus", kraus_ops_tuple = ((6,7), two_mode_kraus_ops_1), name = "detector inefficiency")) # The tuples in this list are defined as (sites, kraus_ops). The sites are the sites where the Kraus ops are applied.
 
             amplification_kraus_ops_0 = single_mode_bosonic_noise_channels(noise_parameter = dark_counts_gain[0], N = N)
             amplification_kraus_ops_1 = single_mode_bosonic_noise_channels(noise_parameter = dark_counts_gain[1], N = N)
             two_mode_kraus_ops_0 = [sp.kron(op1, op2) for op1 in amplification_kraus_ops_0 for op2 in amplification_kraus_ops_0]
             two_mode_kraus_ops_1 = [sp.kron(op1, op2) for op1 in amplification_kraus_ops_1 for op2 in amplification_kraus_ops_1]
-            quantum_channel_list.append(quantum_channel(N = N, num_modes = num_modes, formalism = "kraus", kraus_ops_tuple = ((2,3), two_mode_kraus_ops_0))) # The tuples in this list are defined as (sites, kraus_ops). The sites are the sites where the Kraus ops are applied.
-            quantum_channel_list.append(quantum_channel(N = N, num_modes = num_modes, formalism = "kraus", kraus_ops_tuple = ((6,7), two_mode_kraus_ops_1))) # The tuples in this list are defined as (sites, kraus_ops). The sites are the sites where the Kraus ops are applied.
+            quantum_channel_list.append(quantum_channel(N = N, num_modes = num_modes, formalism = "kraus", kraus_ops_tuple = ((2,3), two_mode_kraus_ops_0), name = "dark counts")) # The tuples in this list are defined as (sites, kraus_ops). The sites are the sites where the Kraus ops are applied.
+            quantum_channel_list.append(quantum_channel(N = N, num_modes = num_modes, formalism = "kraus", kraus_ops_tuple = ((6,7), two_mode_kraus_ops_1), name = "dark counts")) # The tuples in this list are defined as (sites, kraus_ops). The sites are the sites where the Kraus ops are applied.
 
             BSM_POVM_1_OPs = generate_sqrt_POVM_MPO(sites=measurements[1], outcome = det_outcome, total_sites=num_modes, efficiency=1, N=N, pnr = pnr)
             BSM_POVM_1_OPs.extend(generate_sqrt_POVM_MPO(sites=measurements[0], outcome = 0, total_sites=num_modes, efficiency=1, N=N, pnr = pnr))
 
-            det_quantum_channels = [quantum_channel(N = N, num_modes = num_modes, formalism = "closed", unitary_MPOs = DET_MPO, name = "DET") for DET_MPO in BSM_POVM_1_OPs]
+            det_quantum_channels = [quantum_channel(N = N, num_modes = num_modes, formalism = "closed", unitary_MPOs = DET_MPO, name = "Det POVM") for DET_MPO in BSM_POVM_1_OPs]
             quantum_channel_list.extend(det_quantum_channels)
     
             return quantum_channel_list

{trajectree-0.0.2 → trajectree-0.0.4}/trajectree/fock_optics/outputs.py

@@ -20,7 +20,7 @@ def generate_labels(num_systems, N):
         labels.append(new_label[:-1])
     return labels
 
-def read_quantum_state(TN_state, N, num_states = 4, return_dense = False, precision = 10):
+def read_quantum_state(TN_state, N, num_states = 4, return_dense = False, precision = 10, return_string = False):
     dense_state = TN_state.to_dense()
     if return_dense: return dense_state
     dense_state = np.reshape(dense_state.data, (-1, 1), order = 'C')
@@ -28,14 +28,18 @@ def read_quantum_state(TN_state, N, num_states = 4, return_dense = False, precis
     dense_state.data = np.round(dense_state.data, precision)
     dense_state.eliminate_zeros()
 
-    print_quantum_state(N, dense_state, num_states)
+    return print_quantum_state(N, dense_state, num_states, return_string)
 
-def print_quantum_state(N, dense_state, num_states = 4):
+def print_quantum_state(N, dense_state, num_states = 4, return_string = False):
     labels = generate_labels(num_states,N)
     state = dense_state.nonzero()[0]
-    print("Corresponding Basis terms:")
-    for k in state: print(labels[k],"-",k,"-",dense_state[k].data)
-
+    output = []
+    output.append("Corresponding Basis terms:")
+    for k in state: output.append(f"{labels[k]} - {k} - {dense_state[k].data}")
+    if not return_string:
+        print("\n".join(map(str, output)))
+    else:
+        return output
 
 
 def plot_coincidences(coincidence, idler_angles, signal_angles, title = ''):

{trajectree-0.0.2 → trajectree-0.0.4}/trajectree/fock_optics/utils.py

@@ -8,6 +8,8 @@ from quimb.tensor.tensor_core import new_bond #type: ignore
 from quimb.tensor.tensor_1d_compress import enforce_1d_like #type: ignore
 from quimb.tensor.tensor_1d import TensorNetwork1DOperator #type: ignore
 
+from .outputs import read_quantum_state
+
 import qutip as qt
 import re
 
@@ -154,6 +156,7 @@ def create_bimode_bell_state(bell_state, N, error_tolerance = 1e-12):
     elif bell_state == "phi_minus":
         psi = tensor_network_apply_op_vec(NOT_MPO_0, vacuum, compress=True, contract = True, cutoff = error_tolerance)
 
+    # read_quantum_state(psi, N)
     
     psi = tensor_network_apply_op_vec(H_MPO, psi, compress=True, contract = True, cutoff = error_tolerance)
     # read_quantum_state(psi, N, num_states = 2)

{trajectree-0.0.2 → trajectree-0.0.4}/trajectree/sequence/swap.py

@@ -2,6 +2,7 @@ from ..fock_optics.noise_models import *
 from ..fock_optics.measurement import *
 from ..fock_optics.utils import *
 from ..fock_optics.light_sources import *
+from ..fock_optics.outputs import *
 
 from ..trajectory import *
 
@@ -15,8 +16,8 @@ def generate_swapping_circuit(N, num_modes, site_tags, bsm_det_effs, bsm_dark_co
     # Amplitude damping due to fibers
     damping_kraus_ops = single_mode_bosonic_noise_channels(noise_parameter = channel_loss, N = N)
     two_mode_kraus_ops = [sp.kron(op, op) for op in damping_kraus_ops]
-    quantum_channel_list.append(quantum_channel(N = N, num_modes = num_modes, formalism = "kraus", kraus_ops_tuple = ((2,3), two_mode_kraus_ops))) # The tuples in this list are defined as (sites, kraus_ops). The sites are the sites where the Kraus ops are applied.
-    quantum_channel_list.append(quantum_channel(N = N, num_modes = num_modes, formalism = "kraus", kraus_ops_tuple = ((6,7), two_mode_kraus_ops))) # The tuples in this list are defined as (sites, kraus_ops). The sites are the sites where the Kraus ops are applied.
+    quantum_channel_list.append(quantum_channel(N = N, num_modes = num_modes, formalism = "kraus", kraus_ops_tuple = ((2,3), two_mode_kraus_ops), name = "fiber_attenuation")) # The tuples in this list are defined as (sites, kraus_ops). The sites are the sites where the Kraus ops are applied.
+    quantum_channel_list.append(quantum_channel(N = N, num_modes = num_modes, formalism = "kraus", kraus_ops_tuple = ((6,7), two_mode_kraus_ops), name = "fiber_attenuation")) # The tuples in this list are defined as (sites, kraus_ops). The sites are the sites where the Kraus ops are applied.
 
     # Quantum channel for the Bell state measurement
     # BSM_MPOs = bell_state_measurement(None, N, site_tags, num_modes, bsm_det_effs, error_tolerance, measurements = bsm_measurements, pnr = False, use_trajectory = True, return_MPOs = True, compress=True, contract=True)
@@ -29,7 +30,7 @@ def generate_swapping_circuit(N, num_modes, site_tags, bsm_det_effs, bsm_dark_co
 def analyze_entanglement(quantum_channel_list, N, site_tags, num_modes, efficiency, error_tolerance, idler_angles, signal_angles):
     PA_MPOs = rotate_and_measure(None, N, site_tags, num_modes, efficiency, error_tolerance, idler_angles, signal_angles, return_MPOs = True)
     PA_quantum_channels = [quantum_channel(N = N, num_modes = num_modes, formalism = "closed", unitary_MPOs = PA_MPO) for PA_MPO in PA_MPOs]
-    print("num pa quantum channels:", len(PA_quantum_channels))
+    # print("num pa quantum channels:", len(PA_quantum_channels))
     quantum_channel_list.extend(PA_quantum_channels)
 
 
@@ -50,7 +51,7 @@ def perform_swapping_simulation(N, num_modes, num_simulations, params, error_tol
     quantum_channels = generate_swapping_circuit(N, num_modes, psi.site_tags, [params["BSM_det_loss_1"], params["BSM_det_loss_2"]], [params["BSM_dark_counts_1"], params["BSM_dark_counts_2"]], params["BSM_meas"], params["channel_loss"], error_tolerance)
 
     if params["if_analyze_entanglement"]:
-        analyze_entanglement(quantum_channels, N, psi.site_tags, num_modes, params["PA_det_loss"], error_tolerance, params["alpha_list"], params["delta_list"])
+        analyze_entanglement(quantum_channels, N, psi.site_tags, num_modes, params["PA_det_eff"], error_tolerance, params["alpha_list"], params["delta_list"])
 
     t_eval = trajectory_evaluator(quantum_channels)
 
@@ -64,13 +65,13 @@ def perform_swapping_simulation(N, num_modes, num_simulations, params, error_tol
         probabilities.append(psi_iter.normalize())
         
         if params["calc_fidelity"]:
-            fidelity = np.abs(calc_fidelity_swapping(psi_iter, "psi_minus", N, error_tolerance))
+            fidelity = np.abs(calc_fidelity_swapping(psi_iter, "psi_plus", N, error_tolerance))
             fidelities.append(fidelity)
     
         time_taken = time.time() - start
         # print("time taken for simulation", i, ":", time_taken)
 
-    print("completed set", "cache_hits:", t_eval.cache_hit, "cache_partial_hits:", t_eval.cache_partial_hit, "cache_misses:", t_eval.cache_miss,  "time taken:", time_taken)
+    # print("completed set", "cache_hits:", t_eval.cache_hit, "cache_partial_hits:", t_eval.cache_partial_hit, "cache_misses:", t_eval.cache_miss,  "time taken:", time_taken)
 
     return fidelities, probabilities, t_eval
 

{trajectree-0.0.2 → trajectree-0.0.4}/trajectree/trajectory.py

@@ -1,7 +1,7 @@
 import numpy as np
 from quimb.tensor import MatrixProductOperator as mpo #type: ignore
 from quimb.tensor.tensor_arbgeom import tensor_network_apply_op_vec #type: ignore
-
+from .fock_optics.outputs import read_quantum_state
 
 
 class quantum_channel:
@@ -84,7 +84,7 @@ class trajectory_evaluator():
     def cache_trajectree_node(self, trajectory_probs, trajectories):
         sorted_indices = np.argsort(trajectory_probs)
 
-        print("trajectory_probs", trajectory_probs)
+        # print("trajectory_probs", trajectory_probs)
 
         cached_trajectory_indices = sorted_indices[-self.cache_size:]
         cached_trajectories = np.array(trajectories)[cached_trajectory_indices]
@@ -206,5 +206,6 @@ class trajectory_evaluator():
             else:
                 # print("unitary skipped:", self.traversed_nodes)
                 pass
+            pass
 
         return psi