Trajectree 0.0.4__py3-none-any.whl → 0.0.5__py3-none-any.whl

trajectree/fock_optics/devices.py

@@ -4,20 +4,38 @@ import numpy as np
 from numpy import kron
 
 from quimb.tensor import MatrixProductOperator as mpo #type: ignore
+from functools import lru_cache
 
 import qutip as qt
 
 # Beamsplitter transformation
-def create_BS_MPO(site1, site2, theta, total_sites, N, tag = 'BS'): 
+def create_BS_MPO(site1, site2, theta, total_sites, N, return_unitary = False, tag = 'BS'): 
+    
+    """
+    This is a convenience function for legacy implementations. Preferably, don't  use this. Only use the generalized mode mixer.
 
-    a = qt.destroy(N).full()
-    a_dag = a.T
-    I = np.eye(N)
+    As can be inferred from the call to the generalized_mode_mixer function, the beamsplitter transformation is equivalent to an ry rotation. 
+    The specific form is chosen because legacy code used this definition. 
+    When theta = np.pi/4, the transformation corresponds to:
+
+    a -> 1/sqrt(2) (c-d)
+    b -> 1/sqrt(2) (c+d)
+
+    """
+
+    # a = qt.destroy(N).full()
+    # a_dag = a.T
+    # I = np.eye(N)
     
-    # This corresponds to the BS hamiltonian:
+    # # This corresponds to the BS hamiltonian:
+
+    # hamiltonian_BS = -theta * ( kron(I, a_dag)@kron(a, I) - kron(I, a)@kron(a_dag, I) )
+    # unitary_BS = expm(hamiltonian_BS)
+
+    unitary_BS = generalized_mode_mixer_unitary(-2*theta, 0, 0, 0, N)
 
-    hamiltonian_BS = -theta * ( kron(I, a_dag)@kron(a, I) - kron(I, a)@kron(a_dag, I) )
-    unitary_BS = expm(hamiltonian_BS)
+    if return_unitary: 
+        return unitary_BS
 
     # print("unitary_BS", unitary_BS)
 
@@ -26,33 +44,117 @@ def create_BS_MPO(site1, site2, theta, total_sites, N, tag = 'BS'):
     return BS_MPO
 
 
-def generalized_mode_mixer(site1, site2, theta, phi, psi, lamda, total_sites, N, tag = 'MM'): 
+# def generalized_mode_mixer(site1, site2, theta, phi, psi, lamda, total_sites, N, tag = 'MM'): 
+#     """
+#     Deprticated, do not use!
+#     """
 
-    a = qt.destroy(N).full()
-    a_dag = a.T
-    I = np.eye(N)
+#     a = qt.destroy(N).full()
+#     a_dag = a.T
+#     I = np.eye(N)
     
-    # This corresponds to the BS hamiltonian: This is a different difinition from the one in 
-    # create_BS_MPO. This is because of how the generalized beamsplitter is defined in DOI: 10.1088/0034-4885/66/7/203 . 
-    hamiltonian_BS = theta * (kron(a_dag, I)@kron(I, a) + kron(a, I)@kron(I, a_dag))
-    unitary_BS = expm(-1j * hamiltonian_BS)
+#     # This corresponds to the BS hamiltonian: This is a different difinition from the one in 
+#     # create_BS_MPO. This is because of how the generalized beamsplitter is defined in DOI: 10.1088/0034-4885/66/7/203 . 
+#     hamiltonian_BS = theta * (kron(a_dag, I)@kron(I, a) + kron(a, I)@kron(I, a_dag))
+#     unitary_BS = expm(-1j * hamiltonian_BS)
 
-    # print("unitary_BS\n", np.round(unitary_BS, 4))
+#     # print("unitary_BS\n", np.round(unitary_BS, 4))
 
-    pre_phase_shifter = np.kron(phase_shifter(N, phi[0]/2), phase_shifter(N, phi[1]/2))
-    post_phase_shifter = np.kron(phase_shifter(N, psi[0]/2), phase_shifter(N, psi[1]/2))
-    global_phase_shifter = np.kron(phase_shifter(N, lamda[0]/2), phase_shifter(N, lamda[1]/2))
+#     pre_phase_shifter = np.kron(phase_shifter(N, phi[0]/2), phase_shifter(N, phi[1]/2))
+#     post_phase_shifter = np.kron(phase_shifter(N, psi[0]/2), phase_shifter(N, psi[1]/2))
+#     global_phase_shifter = np.kron(phase_shifter(N, lamda[0]/2), phase_shifter(N, lamda[1]/2))
 
-    # This construction for the generalized beamsplitter is based on the description in paper DOI: 10.1088/0034-4885/66/7/203
-    generalized_BS = global_phase_shifter @  (pre_phase_shifter @ unitary_BS @ post_phase_shifter)
+#     # This construction for the generalized beamsplitter is based on the description in paper DOI: 10.1088/0034-4885/66/7/203
+#     generalized_BS = global_phase_shifter @  (pre_phase_shifter @ unitary_BS @ post_phase_shifter)
 
-    # print("generalized_BS\n", np.round(generalized_BS, 4))
+#     # print("generalized_BS\n", np.round(generalized_BS, 4))
 
-    BS_MPO = mpo.from_dense(generalized_BS, dims = N, sites = (site1,site2), L=total_sites, tags=tag)
-    # BS_MPO = BS_MPO.fill_empty_sites(mode = "full")
+#     BS_MPO = mpo.from_dense(generalized_BS, dims = N, sites = (site1,site2), L=total_sites, tags=tag)
+#     # BS_MPO = BS_MPO.fill_empty_sites(mode = "full")
+#     return BS_MPO
+
+
+# def phase_shifter(N, theta):
+#     """
+#     Depricated, do not use!
+#     """
+#     diag = [np.exp(1j * theta * i) for i in range(N)]
+#     return np.diag(diag, k=0)
+
+
+def rx(omega, N, return_unitary = False, site1 = None, site2 = None, total_sites = None, tag = 'rx'):
+    L_t, L_x, L_y, L_z = generate_angular_momentum_operators(N)
+    unitary_rx = expm(-1j * omega * L_x)
+    if return_unitary:
+        return unitary_rx
+    BS_MPO = mpo.from_dense(unitary_rx, dims = N, sites = (site1,site2), L=total_sites, tags=tag)
     return BS_MPO
 
+def ry(theta, N, return_unitary = False, site1 = None, site2 = None, total_sites = None, tag = 'ry'):
+    L_t, L_x, L_y, L_z = generate_angular_momentum_operators(N)
+    unitary_ry = expm(-1j * theta * L_y)
+    if return_unitary:
+        return unitary_ry
+    BS_MPO = mpo.from_dense(unitary_ry, dims = N, sites = (site1,site2), L=total_sites, tags=tag)
+    return BS_MPO
+
+def rz(phi, N, return_unitary = False, site1 = None, site2 = None, total_sites = None, tag = 'rz'):
+    L_t, L_x, L_y, L_z = generate_angular_momentum_operators(N)
+    unitary_rz = expm(-1j * phi * L_z)
+    if return_unitary:
+        return unitary_rz
+    BS_MPO = mpo.from_dense(unitary_rz, dims = N, sites = (site1,site2), L=total_sites, tags=tag)
+    return BS_MPO
+
+def global_phase(lamda, N, return_unitary = False, site1 = None, site2 = None, total_sites = None, tag = 'global_phase'):
+    L_t, L_x, L_y, L_z = generate_angular_momentum_operators(N)
+    unitary_global_phase = expm(-1j * lamda * L_t)
+    if return_unitary:
+        return unitary_global_phase
+    BS_MPO = mpo.from_dense(unitary_global_phase, dims = N, sites = (site1,site2), L=total_sites, tags=tag)
+    return BS_MPO
+
+def single_mode_phase(lamda, N):
+    a = qt.destroy(N).full()
+    a_dag = a.T
+    I = np.eye(N)
 
-def phase_shifter(N, theta):
-    diag = [np.exp(1j * theta * i) for i in range(N)]
-    return np.diag(diag, k=0)
+    unitary_phase = expm(-1j * (lamda/2) * a_dag @ a)
+    return unitary_phase
+
+@lru_cache(maxsize=32)
+def generate_angular_momentum_operators(N):
+    """
+    This generates the angular momentum operators for polarization two polarization modes using the Jordan-Schwinger representation. 
+    See sec. 4.2 in DOI: 10.1088/0034-4885/66/7/203
+    """
+    a = qt.destroy(N).full()
+    a_dag = a.T
+    I = np.eye(N)
+
+    a1 = kron(I, a)
+    a2 = kron(a, I)
+    a1_dag = a1.T
+    a2_dag = a2.T
+    
+    L_t = 0.5 * (a1_dag @ a1 + a2_dag @ a2)
+    L_x = 0.5 * (a1_dag @ a2 + a2_dag @ a1)
+    L_y = 0.5j * (a2_dag @ a1 - a1_dag @ a2)
+    L_z = 0.5 * (a1_dag @ a1 - a2_dag @ a2)
+
+    return L_t, L_x, L_y, L_z
+
+def generalized_mode_mixer_unitary(theta, phi, psi, lamda, N): 
+    """
+    This generates the generalized beamsplitter operator. 
+    See eq. 4.12 in DOI: 10.1088/0034-4885/66/7/203
+    """
+    unitary_BS = rz(phi, N, return_unitary=True) @ ry(theta, N, return_unitary=True) @ rz(psi, N, return_unitary=True) @ global_phase(lamda, N, return_unitary=True)
+    return unitary_BS
+
+def generalized_mode_mixer(site1, site2, theta, phi, psi, lamda, total_sites, N, tag = 'MM'):
+    generalized_BS = generalized_mode_mixer_unitary(theta, phi, psi, lamda, N)
+    
+    BS_MPO = mpo.from_dense(generalized_BS, dims = N, sites = (site1,site2), L=total_sites, tags=tag)
+#     # BS_MPO = BS_MPO.fill_empty_sites(mode = "full")
+    return BS_MPO

trajectree/fock_optics/light_sources.py

@@ -15,12 +15,18 @@ import qutip as qt
 from math import factorial
 
 
-def create_TMSV_OP_Dense(N, mean_photon_num):
+def create_TMSV_OP_Dense(N, mean_photon_num, phi = np.pi, theta = np.pi):
     a = qt.destroy(N).full()
     a_dag = a.T
     truncation = (N-1)   
 
-    op = expm(1j * mean_photon_num * (kron(a_dag, a_dag) + kron(a, a)))
+    # We convert the mean photon number to the squeezing parameter chi using the relation in paper: https://doi.org/10.1103/PhysRevA.98.063842
+    chi = np.asinh(np.sqrt(mean_photon_num))
+
+    # op = expm(np.exp(1j * phi) * chi * (kron(a_dag, a_dag) + np.exp(1j * theta) * kron(a, a)))
+    # op = np.round(op, 12)
+    op = expm(1j* chi * (kron(a_dag, a_dag) + kron(a, a)))
+    # op = expm(0.24 * (kron(a_dag, a_dag) + kron(a, a)))
 
     return op
 

trajectree/fock_optics/measurement.py

@@ -1,6 +1,6 @@
-from .devices import generalized_mode_mixer, create_BS_MPO
+from .devices import generalized_mode_mixer, create_BS_MPO, ry
 from ..trajectory import quantum_channel
-from .noise_models import single_mode_bosonic_noise_channels
+from .noise_models import single_mode_bosonic_noise_channels, general_mixed_bs_noise_model, depolarizing_operators
 
 from scipy.linalg import sqrtm
 from scipy import sparse as sp
@@ -79,9 +79,11 @@ def create_PNR_POVM_OP_Dense(eff, outcome, N, debug = False):
 
 def generate_sqrt_POVM_MPO(sites, outcome, total_sites, efficiency, N, pnr = False, tag = "POVM"):
     if pnr:
-        dense_op = sqrtm(create_PNR_POVM_OP_Dense(efficiency, outcome, N)).astype(np.complex128)
+        # dense_op = sqrtm(create_PNR_POVM_OP_Dense(efficiency, outcome, N)).astype(np.complex128)
+        dense_op = (create_PNR_POVM_OP_Dense(efficiency, outcome, N)).astype(np.complex128)
     else:
-        dense_op = sqrtm(create_threshold_POVM_OP_Dense(efficiency, outcome, N)).astype(np.complex128)
+        # dense_op = sqrtm(create_threshold_POVM_OP_Dense(efficiency, outcome, N)).astype(np.complex128)
+        dense_op = (create_threshold_POVM_OP_Dense(efficiency, outcome, N)).astype(np.complex128)
 
     sqrt_POVM_MPOs = []
     for i in sites:
@@ -90,7 +92,7 @@ def generate_sqrt_POVM_MPO(sites, outcome, total_sites, efficiency, N, pnr = Fal
     return sqrt_POVM_MPOs
 
 
-def bell_state_measurement(psi, N, site_tags, num_modes, efficiencies, dark_counts_gain,  error_tolerance, beamsplitters = [[2,6],[3,7]], measurements = {0:(2,7), 1:(3,6)}, pnr = False, det_outcome = 1, use_trajectory = False, return_MPOs = False, compress = True, contract = True):
+def bell_state_measurement(psi, N, site_tags, num_modes, efficiencies, dark_counts,  error_tolerance, beamsplitters = [[2,6],[3,7]], measurements = {0:(2,7), 1:(3,6)}, depolarizing_error = False, damping_error = True, pnr = False, det_outcome = 1, use_trajectory = False, return_MPOs = False, compress = True, contract = True):
 
     """Perform Bell state measrement or return the MPOs used in the measurement.
     Args:
@@ -128,28 +130,29 @@ def bell_state_measurement(psi, N, site_tags, num_modes, efficiencies, dark_coun
         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 = "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), 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), 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.
+            
+            if damping_error:
+                damping_and_loss_channel0 = general_mixed_bs_noise_model(dark_count_rate = dark_counts[0], eta = efficiencies[0], N = N)
+                damping_and_loss_channel1 = general_mixed_bs_noise_model(dark_count_rate = dark_counts[1], eta = efficiencies[1], N = N)
+                # two_mode_kraus_ops_0 = [sp.kron(op1, op2) for op1 in damping_and_loss_channel0 for op2 in damping_and_loss_channel0]
+                # two_mode_kraus_ops_1 = [sp.kron(op1, op2) for op1 in damping_and_loss_channel1 for op2 in damping_and_loss_channel1]
+                quantum_channel_list.append(quantum_channel(N = N, num_modes = num_modes, formalism = "kraus", kraus_ops_tuple = ((2,), damping_and_loss_channel0), name = "BSM detector")) # 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 = ((3,), damping_and_loss_channel0), name = "BSM detector")) # 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,), damping_and_loss_channel1), name = "BSM detector")) # 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 = ((7,), damping_and_loss_channel1), name = "BSM detector")) # The tuples in this list are defined as (sites, kraus_ops). The sites are the sites where the Kraus ops are applied.
+
+            if depolarizing_error:
+                depolarizing_channels = depolarizing_operators(depolarizing_probability = 0.5, N = N)
+                quantum_channel_list.append(quantum_channel(N = N, num_modes = num_modes, formalism = "kraus", kraus_ops_tuple = ((2,3), depolarizing_channels), name = "BSM depol"))
+                quantum_channel_list.append(quantum_channel(N = N, num_modes = num_modes, formalism = "kraus", kraus_ops_tuple = ((6,7), depolarizing_channels), name = "BSM depol"))
 
             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 POVM") for DET_MPO in BSM_POVM_1_OPs]
-            quantum_channel_list.extend(det_quantum_channels)
+            expectation_ops = [quantum_channel(N = N, num_modes = num_modes, formalism = "closed", unitary_MPOs = DET_MPO, expectation = False, name = "Det POVM") for DET_MPO in BSM_POVM_1_OPs]
+            # quantum_channel_list.extend(expectation_ops)
     
-            return quantum_channel_list
+            return quantum_channel_list, expectation_ops 
 
         returned_MPOs.extend(BSM_POVM_1_OPs) # Collect all the MPOs in a list and return them. The operators are ordered as such: 
 
@@ -168,52 +171,85 @@ def bell_state_measurement(psi, N, site_tags, num_modes, efficiencies, dark_coun
 
 
 
-def rotate_and_measure(psi, N, site_tags, num_modes, efficiency, error_tolerance, idler_angles, signal_angles, rotations = {"signal":(4,5), "idler":(0,1)}, measurements = {1:(0,4), 0:(1,5)}, pnr = False, det_outcome = 1, return_MPOs = False, compress = True, contract = True, draw = False):
+def rotate_and_measure(psi, N, site_tags, num_modes, efficiency, error_tolerance, idler_angles, signal_angles, dark_counts = [3e-5,3e-5], rotations = {"signal":(4,5), "idler":(0,1)}, measurements = {1:(0,4), 0:(1,5)}, depolarizing_error = False, damping_error = True, pnr = False, det_outcome = 1, return_MPOs = False, return_quantum_channel = False, compress = True, contract = True, draw = False):
     # idler_angles = [0]
     # angles = [np.pi/4]
 
+    # A dict is used when the user wants to rotate around multiple axes of the bloch sphere. Otherwise, if its a list, then 
+    # we assume all measurements around the y axis.
+    # if type(idler_angles) != dict:
+    #     idler_angles = {"theta": idler_angles, "phi":[0]*len(idler_angles), "psi":[0]*len(idler_angles)}
+    # if type(signal_angles) != dict:
+    #     signal_angles = {"theta": signal_angles, "phi":[0]*len(signal_angles), "psi":[0]*len(signal_angles)}
+    
+
     coincidence = []
 
     POVM_1_OPs = generate_sqrt_POVM_MPO(sites = measurements[1], outcome = det_outcome, total_sites=num_modes, efficiency=efficiency, N=N, pnr = pnr)
     POVM_0_OPs = generate_sqrt_POVM_MPO(sites = measurements[0], outcome = 0, total_sites=num_modes, efficiency=efficiency, N=N, pnr = pnr)
-    # POVM_0_OPs = generate_sqrt_POVM_MPO(sites=(0,4), outcome = 0, total_sites=num_modes, efficiency=efficiency, N=N, pnr = pnr)
-    # enforce_1d_like(POVM_OP, site_tags=site_tags, inplace=True)
 
     meas_ops = POVM_1_OPs
     meas_ops.extend(POVM_0_OPs)
 
-    for i, idler_angle in enumerate(idler_angles):
+    for i in range(len(idler_angles)):
         coincidence_probs = []
 
-        # rotator_node_1 = create_BS_MPO(site1 = rotations["idler"][0], site2 = rotations["idler"][1], theta=idler_angle, total_sites = num_modes, N = N, tag = r"$Rotator_I$")
-        ######################
-        # We make this correction here since the rotator hamiltonian is 1/2(a_v b_h + a_h b_v), which does not show up in the bs unitary, whose function we are reusing to 
-        # rotate the state.
-        rotator_node_1 = generalized_mode_mixer(site1 = rotations["idler"][0], site2 = rotations["idler"][1], theta = -idler_angle/2, phi = [0,0], psi = [0,0], lamda = [0,0], total_sites = num_modes, N = N, tag = 'MM')
-
+        # rotator_node_1 = generalized_mode_mixer(site1 = rotations["idler"][0], site2 = rotations["idler"][1], theta = idler_angles[i], phi = 0, psi = 0, lamda = 0, total_sites = num_modes, N = N, tag = 'MM')
+        rotator_node_1 = ry(idler_angles[i], N, site1 = rotations["idler"][0], site2 = rotations["idler"][1], total_sites = num_modes, tag = 'ry')
         
         enforce_1d_like(rotator_node_1, site_tags=site_tags, inplace=True)
         rotator_node_1.add_tag("L5")
-        if not return_MPOs: # If the user wants the MPOs, we don't need to apply the rotator to the state.
+        if not return_MPOs and not return_quantum_channel: # If the user wants the MPOs, we don't need to apply the rotator to the state.
             idler_rotated_psi = tensor_network_apply_op_vec(rotator_node_1, psi, compress=compress, contract = contract, cutoff = error_tolerance)
 
 
-        for j, angle in enumerate(signal_angles):
+        for j in range(len(signal_angles)):
             # print("idler:", i, "signal:", j)
         
             # rotator_node_2 = create_BS_MPO(site1 = rotations["signal"][0], site2 = rotations["signal"][1], theta=angle, total_sites = num_modes, N = N, tag = r"$Rotator_S$")
             ##########################
             # We make this correction here since the rotator hamiltonian is 1/2(a_v b_h + a_h b_v), which does not show up in the bs unitary, whose function we are reusing to 
             # rotate the state.
-            rotator_node_2 = generalized_mode_mixer(site1 = rotations["signal"][0], site2 = rotations["signal"][1], theta = -angle/2, phi = [0,0], psi = [0,0], lamda = [0,0], total_sites = num_modes, N = N, tag = 'MM') 
-            
+            # rotator_node_2 = generalized_mode_mixer(site1 = rotations["signal"][0], site2 = rotations["signal"][1], theta = signal_angles[j], phi = 0, psi = 0, lamda = 0, total_sites = num_modes, N = N, tag = 'MM') 
+            rotator_node_2 = ry(signal_angles[j], N, site1 = rotations["signal"][0], site2 = rotations["signal"][1], total_sites = num_modes, tag = 'ry')
+            # print("checling node2 unitarity:", sp.csr_array(np.round(rotator_node_2.to_dense() @ rotator_node_2.to_dense().T.conj() - np.eye(N**2), 5)))
             
             enforce_1d_like(rotator_node_2, site_tags=site_tags, inplace=True)
 
             if return_MPOs:
                 meas_ops = [rotator_node_1, rotator_node_2] + meas_ops # Collect all the MPOs in a list and return them
                 return meas_ops
-        
+
+            if return_quantum_channel:
+                quantum_channel_list = []
+                quantum_channel_list.append(quantum_channel(N = N, num_modes = num_modes, formalism = "closed", unitary_MPOs = rotator_node_1, name = "Idler Rotator"))
+                quantum_channel_list.append(quantum_channel(N = N, num_modes = num_modes, formalism = "closed", unitary_MPOs = rotator_node_2, name = "Signal Rotator"))
+
+                if damping_error:
+                    damping_and_loss_channel0 = general_mixed_bs_noise_model(dark_count_rate = dark_counts[0], eta = efficiency, N = N)
+                    damping_and_loss_channel1 = general_mixed_bs_noise_model(dark_count_rate = dark_counts[1], eta = efficiency, N = N)
+                    # two_mode_kraus_ops_0 = [sp.kron(op1, op2) for op1 in damping_and_loss_channel0 for op2 in damping_and_loss_channel0]
+                    # two_mode_kraus_ops_1 = [sp.kron(op1, op2) for op1 in damping_and_loss_channel1 for op2 in damping_and_loss_channel1]
+                    quantum_channel_list.append(quantum_channel(N = N, num_modes = num_modes, formalism = "kraus", kraus_ops_tuple = ((rotations["idler"][0],), damping_and_loss_channel0), name = "PA detector")) # 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 = ((rotations["idler"][1],), damping_and_loss_channel0), name = "PA detector")) # 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 = ((rotations["signal"][0],), damping_and_loss_channel1), name = "PA detector")) # 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 = ((rotations["signal"][1],), damping_and_loss_channel1), name = "PA detector")) # The tuples in this list are defined as (sites, kraus_ops). The sites are the sites where the Kraus ops are applied.
+
+                if depolarizing_error:
+                    depolarizing_channels = depolarizing_operators(depolarizing_probability = 0.5, N = N)
+                    quantum_channel_list.append(quantum_channel(N = N, num_modes = num_modes, formalism = "kraus", kraus_ops_tuple = ((0,1), depolarizing_channels), name = "BSM depol"))
+                    quantum_channel_list.append(quantum_channel(N = N, num_modes = num_modes, formalism = "kraus", kraus_ops_tuple = ((4,5), depolarizing_channels), name = "BSM depol"))
+                
+                POVM_1_OPs = generate_sqrt_POVM_MPO(sites=measurements[1], outcome = det_outcome, total_sites=num_modes, efficiency=1, N=N, pnr = pnr)
+                POVM_1_OPs.extend(generate_sqrt_POVM_MPO(sites=measurements[0], outcome = 0, total_sites=num_modes, efficiency=1, N=N, pnr = pnr))
+
+                expectation_ops = [quantum_channel(N = N, num_modes = num_modes, formalism = "closed", unitary_MPOs = DET_MPO, expectation = False, name = "Det POVM") for DET_MPO in POVM_1_OPs]
+                # quantum_channel_list.extend(expectation_ops)
+    
+
+                return quantum_channel_list, expectation_ops
+
+
             # Rotate and measure:
             rotator_node_2.add_tag("L5")
             rho_rotated = tensor_network_apply_op_vec(rotator_node_2, idler_rotated_psi, compress=compress, contract = contract, cutoff = error_tolerance)

trajectree/fock_optics/noise_models.py

@@ -1,14 +1,19 @@
 from scipy import sparse as sp
 from scipy.linalg import expm
+from .devices import rx, ry, rz, global_phase
 
 import numpy as np
-
+from numpy import sqrt
 import qutip as qt
 from math import factorial
+from functools import lru_cache
+
 
 def single_mode_bosonic_noise_channels(noise_parameter, N):
     """This function produces the Kraus operatorsd for the single mode bosonic noise channels. This includes pure loss and 
     pure gain channels. The pure gain channel is simply the transpose of the pure loss channel.
+
+    This implementation is based on the definitions in the paper: https://doi.org/10.1103/PhysRevA.97.032346
     
     Args:
         noise_parameter (float): The noise parameter, (loss for pure loss and gain for pure gain channels). For the pure loss channel, this 
@@ -38,4 +43,109 @@ def single_mode_bosonic_noise_channels(noise_parameter, N):
         for l in range(N):
             kraus_ops[l] = kraus_ops[l].T.conjugate()
 
-    return kraus_ops
+    return kraus_ops
+
+def _nck(n,k):
+    """Compute the binomial coefficient "n choose k"."""
+    if k < 0 or k > n:
+        return 0
+    return factorial(n) / (factorial(k) * factorial(n - k))
+
+def general_coherent_bs_noise_model(bath_parameter, theta, N, bath_type='coherent'):
+    """This function produces the Kraus operators for a general beamsplitter noise model with a pure coherent bath.
+    
+    Args:
+        bath_parameter (float): The parameter of the bath (thermal or coherent).
+        theta (float): The beamsplitter transmissivity.
+        N (int): local Hilbert space dimension being considered.
+    """
+    a = qt.destroy(N).full()
+    a_dag = qt.create(N).full()
+    n = a_dag @ a
+
+    basis = lambda i: qt.states.basis(N, i).full()
+    if bath_type == 'coherent':
+        bath_state = lambda n: np.sqrt(np.exp(-np.abs(bath_parameter)**2) / factorial(n)) * bath_parameter**n 
+        
+    kraus_ops = []
+
+    for k in range(N):
+        kraus_op = 0
+        for n in range(N):
+            for q in range(N):
+                coeff = 0
+                for r_2 in range(n):
+                    coeff += bath_state(n) * np.sqrt(_nck(q, q+n-(k+r_2)) * _nck(n, r_2)) * (1j)**(n-r_2) * np.cos(theta)**(k+2*r_2-n) * np.sin(theta)**(q+2*n - k - 2*r_2)
+                kraus_op += coeff * basis(q+n-k) @ basis(q).T
+        kraus_ops.append(kraus_op)
+
+    return kraus_ops
+
+
+def general_mixed_bs_noise_model(dark_count_rate, eta, N):
+    """This function produces the Kraus operators for a general beamsplitter noise model with mixed thermal bath.
+    
+    Args:
+        dark_count_rate (float): Rate of detector dark counts per second
+        eta (float): The beamsplitter transmissivity.
+        N (int): local Hilbert space dimension being considered.
+    """
+    a = qt.destroy(N).full()
+    a_dag = qt.create(N).full()
+    n = a_dag @ a
+
+    basis = lambda i: qt.states.basis(N, i).full()
+    r = np.atanh(np.sqrt(dark_count_rate/(1-eta+eta*dark_count_rate))) # We can also calulate the mean photon number of the fictitious thermal bath as sinh(r)**2
+
+    kraus_ops = []
+
+    theta = np.arcsin(np.sqrt(eta))
+
+    for n in range(N):
+        bath_state = np.sqrt(np.cosh(r)**(-2) * np.tanh(r)**(2*n)) 
+        for k in range(N):
+            kraus_op = 0
+            # flag = False
+            for q in range(N):
+                if q+n-k < N and q+n-k >= 0:
+                    # flag = True
+                    coeff = 0
+                    for r_2 in range(n+1):
+                        coeff += bath_state * np.sqrt(_nck(q, q+n-(k+r_2)) * _nck(n, r_2)) * (-1)**(n-r_2) * np.cos(theta)**(k+2*r_2-n) * np.sin(theta)**(q+2*n - k - 2*r_2)
+                        # try:
+                        kraus_op += coeff * sp.csr_array((basis(q+n-k) @ basis(q).T))
+                        # except:
+                        #     raise ValueError(f"Basis {q+n-k} is not possible for N={N}")
+            # if flag:
+            kraus_ops.append(kraus_op)
+
+    return kraus_ops
+                
+            
+
+@lru_cache(maxsize=100)
+def depolarizing_operators(depolarizing_probability, N, bias = (1/3, 1/3, 1/3)):
+    ops = []
+    ops.append(sqrt(1-depolarizing_probability) * sp.eye(N**2, format="csc"))
+    ops.append(sqrt(depolarizing_probability * bias[0]) * sp.csr_matrix(rx(np.pi, N, return_unitary=True)))
+    ops.append(sqrt(depolarizing_probability * bias[1]) * sp.csr_matrix(ry(np.pi, N, return_unitary=True)))
+    ops.append(sqrt(depolarizing_probability * bias[2]) * sp.csr_matrix(rz(np.pi, N, return_unitary=True)))
+    return ops
+
+def two_qubit_depolarizing_channel(depolarizing_probability, N):
+    """This function produces the Kraus operators for the two qubit depolarizing channel.
+    
+    Args:
+        depolarizing_probability (float): The depolarizing probability.
+        N (int): local Hilbert space dimension being considered.
+    """
+    single_qubit_ops = [sp.csr_matrix(global_phase(0, N, return_unitary = True)), sp.csr_matrix(rx(np.pi, N, return_unitary=True)), sp.csr_matrix(ry(np.pi, N, return_unitary=True)), sp.csr_matrix(rz(np.pi, N, return_unitary=True))]
+    ops = []
+    ops.append(sqrt(1-(15/16)*depolarizing_probability) * sp.eye(N**4, format="csc"))
+    for i in range(4):
+        for j in range(4):
+            if i == 0 and j == 0:
+                continue
+            else:
+                ops.append(sqrt(depolarizing_probability/16) * sp.kron(single_qubit_ops[i], single_qubit_ops[j]))
+    return ops

trajectree/{optical_quant_info.py → fock_optics/optical_quant_info.py}

@@ -4,7 +4,7 @@ from trajectree.fock_optics.light_sources import *
 from trajectree.fock_optics.devices import *
 from trajectree.trajectory import *
 
-from trajectree.protocols.swap import perform_swapping_simulation
+from trajectree.sequence.swap import perform_swapping_simulation
 
 import numpy as np
 
@@ -127,11 +127,21 @@ def CNOT(psi_control_modes, psi_target_modes, psi_control, psi_target, N, mean_p
     return psi
 
 
-def H(psi, sites, N, error_tolerance):
-    # TODO: This function does not work for N > 2.
+def H(psi, sites, N, error_tolerance, return_unitary = False, tag = 'H'):
     # This definition is based on the paper: https://arxiv.org/pdf/quant-ph/9706022
-    H = generalized_mode_mixer(sites[0], sites[1], -np.pi/4, [0,-np.pi], [0,-np.pi], [0,0], psi.L, N)
-    # H = generalized_mode_mixer(0, 1, np.pi/4, 0, 0, 0, 2, N)
+   
+    # First, we implement a beamsplitter. We found this beamsplitter configuration using trial and error to match the Hadamard transformation.
+    unitary_H = generalized_mode_mixer_unitary(np.pi/2, np.pi/2, -np.pi/2, 2*np.pi, N)
+    # Next, we implement the -pi/2 (single mode) phase shifters on the |V> mode, before and after the beamsplitter. 
+    # Note that although it appears as if we are applying the phase shift on the |H> arm and not on the |V> arm. However, that is not true. 
+    # In the photonic representation we are using, the |0H1V> = |1> and |1H0V> = |0>, but if you look at the matrix itself, the |0H1V> state 
+    # comes first and the |1H0V> state comes second. So, according to the matrix representation, the two modes are reversed. Hence, the different phase configuration.  
+    unitary_H = np.kron(single_mode_phase(-np.pi, N), np.eye(N)) @ unitary_H @ np.kron(single_mode_phase(-np.pi, N), np.eye(N))
+
+    if return_unitary:
+        return unitary_H
+    
+    H = mpo.from_dense(unitary_H, dims = N, sites = (sites[0],sites[1]), L=psi.L, tags=tag)
     enforce_1d_like(H, site_tags=psi.site_tags, inplace=True)
     psi = tensor_network_apply_op_vec(H, psi, compress=True, contract = True, cutoff = error_tolerance)
     return psi

trajectree/fock_optics/outputs.py

@@ -10,7 +10,7 @@ def generate_labels(num_systems, N):
     labels = []
     state_labels = []
     for i in range(dim):
-        state_labels.append(f"{i//N}H{i%N}V")
+        state_labels.append(f"{i%N}H{i//N}V")
     # print("sates:", self.state_labels)
     for i in range(dim**num_systems):
         new_label = ""