Trajectree 0.0.0__tar.gz

trajectree-0.0.0/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

trajectree-0.0.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: Trajectree
+Version: 0.0.0
+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
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: quimb
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Dynamic: license-file
+
+Trajectree is a quantum trajectory theory and tensor network based quantum optics simulator. 

trajectree-0.0.0/README.md

@@ -0,0 +1 @@
+Trajectree is a quantum trajectory theory and tensor network based quantum optics simulator. 

trajectree-0.0.0/Trajectree.egg-info/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: Trajectree
+Version: 0.0.0
+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
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: quimb
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Dynamic: license-file
+
+Trajectree is a quantum trajectory theory and tensor network based quantum optics simulator. 

trajectree-0.0.0/Trajectree.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+pyproject.toml
+Trajectree.egg-info/PKG-INFO
+Trajectree.egg-info/SOURCES.txt
+Trajectree.egg-info/dependency_links.txt
+Trajectree.egg-info/requires.txt
+Trajectree.egg-info/top_level.txt
+trajectree/__init__.py
+trajectree/optical_quant_info.py
+trajectree/trajectory.py
+trajectree/experimental/sparse.py
+trajectree/fock_optics/devices.py
+trajectree/fock_optics/light_sources.py
+trajectree/fock_optics/measurement.py
+trajectree/fock_optics/noise_models.py
+trajectree/fock_optics/outputs.py
+trajectree/fock_optics/utils.py
+trajectree/sequence/swap.py

trajectree-0.0.0/Trajectree.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

trajectree-0.0.0/Trajectree.egg-info/requires.txt

@@ -0,0 +1,4 @@
+quimb
+numpy
+scipy
+matplotlib

trajectree-0.0.0/Trajectree.egg-info/top_level.txt

@@ -0,0 +1 @@
+trajectree

trajectree-0.0.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "Trajectree"
+dynamic = ["version"]
+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"
+requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+]
+
+dependencies=[
+  'quimb',
+  'numpy',
+  'scipy',
+  'matplotlib',
+]
+

trajectree-0.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

trajectree-0.0.0/trajectree/experimental/sparse.py

@@ -0,0 +1,115 @@
+from ..fock_optics.measurement import *
+from ..fock_optics.outputs import *
+
+import numpy as np
+import scipy.sparse as sp
+
+# Support functions:
+def create_op(left_indices, op, right_indices, N):
+    if left_indices == 0:
+        return sp.kron(op, sp.eye(N**right_indices))
+    elif right_indices == 0:
+        return sp.kron(sp.eye(N**left_indices), op)
+    else:    
+        out_op = sp.kron(sp.eye(N**left_indices), op)
+        return sp.kron(out_op, sp.eye(N**right_indices))
+def _find_mat_exp(mat):
+    ans = sp.eye(mat.shape[0])
+    intermediate = 1
+    for i in range(1, 50+1):
+        intermediate *= mat/i
+        intermediate.eliminate_zeros()
+        ans += intermediate
+    return ans 
+def read_quantum_state_sparse(sparse_state, N):
+    temp_sparse_state = sp.csr_matrix(sparse_state)
+    temp_sparse_state.data = np.round(temp_sparse_state.data, 10)
+    temp_sparse_state.eliminate_zeros()
+    labels = generate_labels(4,N)
+    state = temp_sparse_state.nonzero()[0]
+    print(f"{len(state)} non-zero elements Corresponding Basis terms:")
+    for k in state: print(labels[k],"-",k,"-",temp_sparse_state[k].data)
+
+def extend_state_sparse(state):
+    return sp.kron(state, state)
+# TMSV_state_dense = extend_state_sparse(TMSV_state)
+
+def bell_state_measurement_sparse(TMSV_state_dense, N, efficiency, a_dag, is_dm = False):
+    # BSM BS implementation
+    BSM_H_0_Mode_op = create_op(2, a_dag, 5, N)
+    print(BSM_H_0_Mode_op.shape, len(BSM_H_0_Mode_op.nonzero()[0]), len(BSM_H_0_Mode_op.nonzero()[1]))
+    BSM_V_0_Mode_op = create_op(3, a_dag, 4, N)
+    BSM_H_1_Mode_op = create_op(6, a_dag, 1, N)
+    BSM_V_1_Mode_op = create_op(7, a_dag, 0, N)
+
+    hamiltonian_BS_H = -np.pi/4 * ( BSM_H_0_Mode_op.T@BSM_H_1_Mode_op - BSM_H_0_Mode_op@BSM_H_1_Mode_op.T )
+    unitary_BS_H = _find_mat_exp(hamiltonian_BS_H)
+
+    hamiltonian_BS_V = -np.pi/4 * ( BSM_V_0_Mode_op.T@BSM_V_1_Mode_op - BSM_V_0_Mode_op@BSM_V_1_Mode_op.T )
+    unitary_BS_V = _find_mat_exp(hamiltonian_BS_V)
+
+
+    # BSM povm implementation
+    povm_op_1 = sp.csr_matrix(create_threshold_POVM_OP_Dense(efficiency, 1, N))
+    povm_op_0 = sp.csr_matrix(create_threshold_POVM_OP_Dense(efficiency, 0, N))
+
+    BSM_povm = create_op(2, povm_op_1, 0, N)
+    BSM_povm = create_op(0, sp.kron(BSM_povm, povm_op_0), 2, N)
+    BSM_povm = sp.kron(BSM_povm, sp.kron(povm_op_0, povm_op_1))
+
+    # print(unitary_BS_V.shape, unitary_BS_H.shape, TMSV_state_dense.shape)
+    
+    if is_dm:
+        post_BS_State = unitary_BS_V @ unitary_BS_H @ TMSV_state_dense @ (unitary_BS_V @ unitary_BS_H).conj().T
+        post_BSM_State = BSM_povm @ post_BS_State @ BSM_povm.conj().T
+    else:
+        post_BS_State = unitary_BS_V @ unitary_BS_H @ TMSV_state_dense
+        post_BSM_State = BSM_povm @ post_BS_State
+
+    # post_BSM_State.data = np.round(post_BSM_State.data, 10)
+    # post_BSM_State.eliminate_zeros()
+
+    return post_BSM_State
+# post_BSM_State = bell_state_measurement_sparse(TMSV_state_dense, N, efficiency)
+
+def rotate_and_measure_sparse(post_BSM_State, N, efficiency, a_dag):
+    # Polarization rotators mode operators
+    rotator_H_0_Mode_op = create_op(0, a_dag, 7, N)
+    rotator_V_0_Mode_op = create_op(1, a_dag, 6, N)
+    rotator_H_1_Mode_op = create_op(4, a_dag, 3, N)
+    rotator_V_1_Mode_op = create_op(5, a_dag, 2, N)
+
+    povm_op_1 = sp.csr_matrix(create_threshold_POVM_OP_Dense(efficiency, 1, N))
+
+    # polarization analysis detector POVMs
+    pol_analyzer_povm = create_op(0, povm_op_1, 3, N)
+    pol_analyzer_povm = create_op(0, sp.kron(pol_analyzer_povm, povm_op_1), 3, N)
+
+    # Applying rotations and measuring
+
+    signal_angles = np.linspace(0, np.pi, 10)
+    # idler_angles = np.linspace(0, np.pi, 20)
+    idler_angles = [0]
+    coincidence = []
+
+    for i, idler_angle in enumerate(idler_angles):
+        coincidence_probs = []
+
+        hamiltonian_rotator_1 = -idler_angle * ( rotator_H_1_Mode_op.T@rotator_V_1_Mode_op - rotator_H_1_Mode_op@rotator_V_1_Mode_op.T )
+        unitary_rotator_1 = _find_mat_exp(hamiltonian_rotator_1)
+        post_idler_detection_state = unitary_rotator_1 @ post_BSM_State
+        # post_idler_detection_state = post_BSM_State
+        
+        for j, angle in enumerate(signal_angles):
+            # print("idler:", i, "signal:", j)
+        
+            hamiltonian_rotator_0 = -angle * ( rotator_H_0_Mode_op.T@rotator_V_0_Mode_op - rotator_H_0_Mode_op@rotator_V_0_Mode_op.T )
+            unitary_rotator_0 = _find_mat_exp(hamiltonian_rotator_0)
+            post_rotations_state = unitary_rotator_0 @ post_idler_detection_state
+
+            measured_state = pol_analyzer_povm @ post_rotations_state
+
+            coincidence_probs.append(sp.linalg.norm(measured_state)**2)
+        coincidence.append(coincidence_probs)
+    return coincidence, idler_angles
+# coincidence, idler_angles = rotate_and_measure_sparse(post_BSM_State, N, efficiency)

trajectree-0.0.0/trajectree/fock_optics/devices.py

@@ -0,0 +1,58 @@
+from scipy.linalg import expm
+
+import numpy as np
+from numpy import kron
+
+from quimb.tensor import MatrixProductOperator as mpo #type: ignore
+
+import qutip as qt
+
+# Beamsplitter transformation
+def create_BS_MPO(site1, site2, theta, total_sites, N, tag = 'BS'): 
+
+    a = qt.destroy(N).full()
+    a_dag = a.T
+    I = np.eye(N)
+    
+    # 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)
+
+    # print("unitary_BS", unitary_BS)
+
+    BS_MPO = mpo.from_dense(unitary_BS, dims = N, sites = (site1,site2), L=total_sites, tags=tag)
+    # BS_MPO = BS_MPO.fill_empty_sites(mode = "full")
+    return BS_MPO
+
+
+def generalized_mode_mixer(site1, site2, theta, phi, psi, lamda, total_sites, N, tag = 'MM'): 
+
+    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)
+
+    # 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))
+
+    # 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))
+
+    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):
+    diag = [np.exp(1j * theta * i) for i in range(N)]
+    return np.diag(diag, k=0)

trajectree-0.0.0/trajectree/fock_optics/light_sources.py

@@ -0,0 +1,123 @@
+from .utils import create_MPO
+from .devices import create_BS_MPO
+
+from scipy import sparse as sp
+from scipy.linalg import expm
+
+import numpy as np
+from numpy.linalg import matrix_power
+from numpy import kron, sqrt
+
+from quimb.tensor.tensor_arbgeom import tensor_network_apply_op_vec #type: ignore
+from quimb.tensor.tensor_1d_compress import enforce_1d_like #type: ignore
+
+import qutip as qt
+from math import factorial
+
+
+def create_TMSV_OP_Dense(N, mean_photon_num):
+    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)))
+
+    return op
+
+
+
+########## Light Source ###########
+
+def light_source(vacuum, N, mean_photon_num, num_modes, error_tolerance, TMSV_indices = ((0,2),(5,7)), compress = True, contract = True):
+
+    psi = vacuum.copy()
+    psi.add_tag("L0")
+    site_tags = psi.site_tags
+
+    # Creating TMSV ops:
+    TMSV_op_dense = create_TMSV_OP_Dense(N, mean_photon_num)
+
+    TMSV_MPO_H = create_MPO(site1 = TMSV_indices[0][0], site2 = TMSV_indices[0][1], total_sites = num_modes, op = TMSV_op_dense, N = N, tag = r"$TMSV_H$")
+    # TMSV_MPO_H.draw()
+    # print("sites present in light_source:", TMSV_MPO_H.sites)
+    enforce_1d_like(TMSV_MPO_H, site_tags=site_tags, inplace=True)
+    # print("sites present in light_source:", TMSV_MPO_H.sites)
+    TMSV_MPO_H.add_tag("L1")
+
+    TMSV_MPO_V = create_MPO(site1 = TMSV_indices[1][0], site2 = TMSV_indices[1][1], total_sites = num_modes, op = TMSV_op_dense, N = N, tag = r"$TMSV_V$")
+    enforce_1d_like(TMSV_MPO_V, site_tags=site_tags, inplace=True)
+    TMSV_MPO_V.add_tag("L1")
+
+    # Creating PBS ops:
+    U_PBS_H_Signal = create_BS_MPO(site1 = 2, site2 = 6, theta=np.pi/2, total_sites = num_modes, N = N, tag = r"$PBS_S$")
+    enforce_1d_like(U_PBS_H_Signal, site_tags=site_tags, inplace=True)
+    U_PBS_H_Signal.add_tag("L1")
+
+    U_PBS_H_Idler = create_BS_MPO(site1 = 0, site2 = 4, theta=np.pi/2, total_sites = num_modes, N = N, tag = r"$PBS_I$")
+    enforce_1d_like(U_PBS_H_Idler, site_tags=site_tags, inplace=True)
+    U_PBS_H_Signal.add_tag("L1")
+
+    # Create entangled state:
+    psi = tensor_network_apply_op_vec(TMSV_MPO_H, psi, compress=compress, contract = contract, cutoff = error_tolerance)
+    psi = tensor_network_apply_op_vec(TMSV_MPO_V, psi, compress=compress, contract = contract, cutoff = error_tolerance)
+    psi = tensor_network_apply_op_vec(U_PBS_H_Idler, psi, compress=compress, contract = contract, cutoff = error_tolerance)
+    psi = tensor_network_apply_op_vec(U_PBS_H_Signal, psi, compress=compress, contract = contract, cutoff = error_tolerance)
+
+    psi.normalize()
+
+    # print("trace is:", np.linalg.norm(psi.to_dense()))
+
+    for _ in range(4):
+        psi.measure(0, remove = True, renorm = True, inplace = True)
+
+    # Not used for TN implermentation. Used for validating impelmentation with dense version
+    TMSV_state = psi.to_dense()
+    TMSV_state = np.reshape(TMSV_state.data, (-1, 1), order = 'C')
+    TMSV_state = sp.csr_matrix(TMSV_state)
+    TMSV_state.data = np.round(TMSV_state.data, 10)
+    TMSV_state.eliminate_zeros()
+
+    return psi, TMSV_state
+
+
+# Generate truncation filter MPO 
+# TODO: Make a function to renormalize a quantum state. How: find the projection of the quantum state onto itself and calculate the 
+# probability. Next, take the square root of this number, divide it by the number nodes in the quantum state and multiply it with 
+# all the states in the MPS. For density matrices, simply find the trace directly and do the same thing as the previous example except
+# for not taking the square root.  The truncation filter would not work without the renormalization 
+def create_truncation_filter_Dense(truncation):
+    # This is only the projection operator. The states need to be normalized first. 
+    N = truncation+1
+    vacuum = np.zeros(N**2)
+    vacuum[0] = 1
+
+    a = qt.destroy(N).full()
+    a_dag = a.T
+    I = np.eye(N)
+
+    # # debug
+    # labels = generate_labels(1,N)
+
+    op = 0
+    for trunc in range(truncation, -1, -1):
+        state = kron(matrix_power(a_dag, trunc), I) @ vacuum / sqrt(factorial(trunc) * factorial(0))
+        op+=np.outer(state, state)
+        coeffs = [trunc+1, 0]
+
+        # # Debug
+        # state_inds = state.nonzero()[0]
+        # print("TMSV state:", [labels[i] for i in state_inds], "Val:", state[state_inds[0]])
+        # print("coeffs", coeffs)
+
+        for i in range(trunc):
+            coeffs = [coeffs[0]-1, coeffs[1]+1]
+            state = kron(a, a_dag) @ state / sqrt((coeffs[0]) * (coeffs[1]))
+            op += np.outer(state, state)
+
+
+            # # debug
+            # state_inds = state.nonzero()[0]
+            # print("TMSV state:", [labels[i] for i in state_inds], "Val:", state[state_inds[0]])
+            # print("coeffs", coeffs)
+
+    return op

trajectree-0.0.0/trajectree/fock_optics/measurement.py

@@ -0,0 +1,236 @@
+from .devices import generalized_mode_mixer, create_BS_MPO
+from ..trajectory import quantum_channel
+from .noise_models import single_mode_bosonic_noise_channels
+
+from scipy.linalg import sqrtm
+from scipy import sparse as sp
+
+import numpy as np
+from numpy.linalg import matrix_power
+from numpy import sqrt
+
+from quimb.tensor import MatrixProductOperator as mpo #type: ignore
+from quimb.tensor.tensor_arbgeom import tensor_network_apply_op_vec #type: ignore
+from quimb.tensor.tensor_1d_compress import enforce_1d_like #type: ignore
+
+import qutip as qt
+from math import factorial
+
+from functools import lru_cache
+
+
+# This is the actual function that generates the POVM operator.
+def create_threshold_POVM_OP_Dense(efficiency, outcome, N):
+    a = qt.destroy(N).full()
+    a_dag = a.T
+    create0 = a_dag * sqrt(efficiency)
+    destroy0 = a * sqrt(efficiency)
+    series_elem_list = [((-1)**i) * matrix_power(create0, (i+1)) @ matrix_power(destroy0, (i+1)) / factorial(i+1) for i in range(N-1)] # (-1)^i * a_dag^(i+1) @ a^(i+1) / (i+1)! = (-1)^(i+2) * a_dag^(i+1) @ a^(i+1) / (i+1)! since goes from 0->n
+    # print(series_elem_list[0])
+    dense_op = sum(series_elem_list)
+
+    if outcome == 0:
+        dense_op = np.eye(dense_op.shape[0]) - dense_op
+    # print(sqrtm(dense_op))
+    return dense_op
+
+@lru_cache(maxsize=20)
+def factorial(x):
+    n = 1
+    for i in range(2, x+1):
+        n *= i
+    return n
+
+@lru_cache(maxsize=20)
+def comb(n, k):
+    return factorial(n) / (factorial(k) * factorial(n - k))
+
+@lru_cache(maxsize=20)
+def projector(n, N):
+    state = np.zeros(N)
+    state[n] = 1
+    return np.outer(state, state)
+
+# Testing stuff out here. 
+def create_PNR_POVM_OP_Dense(eff, outcome, N, debug = False):
+    a_dag = qt.create(N).full()
+    vacuum = np.zeros(N)
+    vacuum[0] = 1
+
+    @lru_cache(maxsize=20)
+    def create_povm_list(eff, N):
+        povms = []
+        # m is the outcome here
+        for m in range(N-1):
+            op = 0
+            for n in range(m, N):
+                op += comb(n,m) * eff**m * (1-eff)**(n-m) * projector(n, N)
+            povms.append(op)
+
+        povms.append(np.eye(N) - sum(povms))
+        return povms
+    
+    povms = create_povm_list(eff, N)
+    if debug:
+        return povms[outcome], povms
+    return povms[outcome]
+
+
+
+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)
+    else:
+        dense_op = sqrtm(create_threshold_POVM_OP_Dense(efficiency, outcome, N)).astype(np.complex128)
+
+    sqrt_POVM_MPOs = []
+    for i in sites:
+        sqrt_POVM_MPOs.append(mpo.from_dense(dense_op, dims = N, sites = (i,), L=total_sites, tags=tag))
+
+    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):
+
+    """Perform Bell state measrement or return the MPOs used in the measurement.
+    Args:
+        psi (mps): The input state to be measured.
+        N (int): local Hilbert space dimension
+        site_tags (list): The tags for the sites in the MPS.
+        num_modes (int): The number of modes in the MPS.
+        efficiencies list[float]: The efficiencies of the (pairs of) detectors in the BSM.
+        error_tolerance (float): The error tolerance for the tensor network.
+        measurements (dict): The sites for the measurements. Default is {1:(2,7), 0:(3,6)}.
+        pnr (bool): Whether to use photon number resolving measurement. Default is False.
+        pnr_outcome (int): The outcome for the photon number resolving measurement. Default is 1. When not using PNR, this can be anything other than 1 since threshold detectors don't distinguish between photon numbers. 
+        return_MPOs (bool): Whether to return the MPOs used in the measurement. Default is False.
+        compress (bool): Whether to compress the MPS after applying the MPOs. Default is True.
+        contract (bool): Whether to contract the MPS after applying the MPOs. Default is True.
+        
+        Returns:
+            mps: The measured state after the Bell state measurement.
+            
+    """
+
+    U_BS_H = create_BS_MPO(site1 = beamsplitters[0][0], site2 = beamsplitters[0][1], theta=np.pi/4, total_sites = num_modes, N = N, tag = r"$U_{BS_H}$")
+    enforce_1d_like(U_BS_H, site_tags=site_tags, inplace=True)
+    U_BS_H.add_tag("L2")
+
+    U_BS_V = create_BS_MPO(site1 = beamsplitters[1][0], site2 = beamsplitters[1][1], theta=np.pi/4, total_sites = num_modes, N = N, tag = r"$U_{BS_V}$")
+    enforce_1d_like(U_BS_V, site_tags=site_tags, inplace=True)
+    U_BS_V.add_tag("L3")
+
+    # Note that these are not used if using trajectree to implement detector inefficiency. 
+    BSM_POVM_1_OPs = generate_sqrt_POVM_MPO(sites=measurements[1], outcome = det_outcome, total_sites=num_modes, efficiency=efficiencies[0], N=N, pnr = pnr)
+    BSM_POVM_1_OPs.extend(generate_sqrt_POVM_MPO(sites=measurements[0], outcome = 0, total_sites=num_modes, efficiency=efficiencies[1], N=N, pnr = pnr))
+
+    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]
+
+            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.
+
+            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.
+
+            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]
+            quantum_channel_list.extend(det_quantum_channels)
+    
+            return quantum_channel_list
+
+        returned_MPOs.extend(BSM_POVM_1_OPs) # Collect all the MPOs in a list and return them. The operators are ordered as such: 
+
+        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]
+
+        return quantum_channel_list
+
+    psi = tensor_network_apply_op_vec(U_BS_H, psi, compress=compress, contract = contract, cutoff = error_tolerance)
+    psi = tensor_network_apply_op_vec(U_BS_V, psi, compress=compress, contract = contract, cutoff = error_tolerance)
+
+    for POVM_OP in BSM_POVM_1_OPs:
+        POVM_OP.add_tag("L4")
+        psi = tensor_network_apply_op_vec(POVM_OP, psi, compress=compress, contract = contract, cutoff = error_tolerance)
+
+    return psi
+
+
+
+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):
+    # idler_angles = [0]
+    # angles = [np.pi/4]
+
+    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):
+        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')
+
+        
+        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.
+            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):
+            # 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') 
+            
+            
+            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
+        
+            # 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)
+
+            # read_quantum_state(psi)
+            # read_quantum_state(rho_rotated)
+
+            for POVM_OP in meas_ops:
+                POVM_OP.add_tag("L6")
+                rho_rotated = tensor_network_apply_op_vec(POVM_OP, rho_rotated, compress=compress, contract = contract, cutoff = error_tolerance)
+        
+            if draw:
+                # only for drawing the TN. Not used otherwise
+                fix = {(f"L{j}",f"I{num_modes - i-1}"):(3*j,i+5) for j in range(10) for i in range(10)}
+                rho_rotated.draw(color = [r'$HH+VV$', r'$U_{BS_H}$', r"$U_{BS_V}$", 'POVM', r'$Rotator_I$', r'$Rotator_S$'], title = "Polarization entanglement swapping MPS", fix = fix, show_inds = True, show_tags = False)
+                # rho_rotated.draw_tn()
+            coincidence_probs.append((rho_rotated.norm())**2)
+        coincidence.append(coincidence_probs)
+    
+    return np.array(coincidence)