def test_extract_unitary_1_mode_fock(self): """Test that unitary extraction works for 1 mode using the fock backend""" self.logTestName() eng_extract, q_extract = sf.Engine(num_subsystems=1) S = sf.ops.Sgate(0.4, -1.2) D = sf.ops.Dgate(2, 0.9) K = sf.ops.Kgate(-1.5) initial_state = np.random.rand(self.D) + 1j * np.random.rand( self.D) # not a state but it doesn't matter with self.eng_sf: sf.ops.Ket(initial_state) | self.q_sf S | self.q_sf D | self.q_sf K | self.q_sf with eng_extract: S | q_extract D | q_extract K | q_extract matrix_extract = extract_unitary(eng_extract, cutoff_dim=self.D) final_state_extract = matrix_extract.dot(initial_state) final_state_sf = self.eng_sf.run().ket() self.assertAllAlmostEqual(final_state_extract, final_state_sf, delta=self.tol)
def setUp(self): super().setUp() self.eng, q = sf.Engine(self.num_subsystems, hbar=self.hbar) self.eng.backend = self.backend self.u1 = random_interferometer(self.num_subsystems) self.u2 = random_interferometer(self.num_subsystems) self.S = random_symplectic(self.num_subsystems) self.V_mixed = random_covariance(self.num_subsystems, hbar=self.hbar, pure=False) self.V_pure = random_covariance(self.num_subsystems, hbar=self.hbar, pure=True) self.A = np.array([[ 1.28931633 + 0.75228801j, 1.45557375 + 0.96825143j, 1.53672608 + 1.465635j ], [ 1.45557375 + 0.96825143j, 0.37611686 + 0.84964159j, 1.25122856 + 1.28071385j ], [ 1.53672608 + 1.465635j, 1.25122856 + 1.28071385j, 1.88217983 + 1.70869293j ]]) self.A -= np.trace(self.A) * np.identity(3) / 3
def test_extract_channel_2_modes(self): """Test that channel extraction works for 2 modes""" self.logTestName() eng_extract, q_extract = sf.Engine(num_subsystems=2) S = sf.ops.Sgate(2) B = sf.ops.BSgate(2.234, -1.165) initial_state = np.random.rand( self.D, self.D, self.D, self.D) + 1j * np.random.rand(self.D, self.D, self.D, self.D) with self.eng_sf: sf.ops.DensityMatrix(initial_state) | (self.q_sf[0], self.q_sf[1]) S | self.q_sf[0] B | self.q_sf S | self.q_sf[1] B | self.q_sf with eng_extract: S | q_extract[0] B | q_extract S | q_extract[1] B | q_extract #vectorize = false choi = extract_channel(eng_extract, cutoff_dim=self.D, vectorize_modes=False, representation='choi') liouville = extract_channel(eng_extract, cutoff_dim=self.D, vectorize_modes=False, representation='liouville') kraus = extract_channel(eng_extract, cutoff_dim=self.D, vectorize_modes=False, representation='kraus') final_rho_sf = self.eng_sf.run().dm() final_rho_choi = np.einsum('abcdefgh,abcd -> efgh', choi, initial_state) final_rho_liouville = np.einsum('abcdefgh,fbhd -> eagc', liouville, initial_state) final_rho_kraus = np.einsum('abcde,cfeg,ahfig -> bhdi', kraus, initial_state, np.conj(kraus)) self.assertAllAlmostEqual(final_rho_choi, final_rho_sf, delta=self.tol) self.assertAllAlmostEqual(final_rho_liouville, final_rho_sf, delta=self.tol) self.assertAllAlmostEqual(final_rho_kraus, final_rho_sf, delta=self.tol)
def setUp(self): super().setUp() self.eng, q = sf.Engine(self.num_subsystems, hbar=self.hbar) self.eng.backend = self.backend self.u1 = random_interferometer(self.num_subsystems) self.u2 = random_interferometer(self.num_subsystems) self.S = random_symplectic(self.num_subsystems) self.V_mixed = random_covariance(self.num_subsystems, hbar=self.hbar, pure=False) self.V_pure = random_covariance(self.num_subsystems, hbar=self.hbar, pure=True)
def test_extract_unitary_2_modes_fock(self): """Test that unitary extraction works for 2 modes using the fock backend""" self.logTestName() eng_extract, q_extract = sf.Engine(num_subsystems=2) S = sf.ops.Sgate(2) B = sf.ops.BSgate(2.234, -1.165) initial_state = np.complex64( np.random.rand(self.D, self.D) + 1j * np.random.rand(self.D, self.D)) with self.eng_sf: sf.ops.Ket(initial_state) | (self.q_sf[0], self.q_sf[1]) S | self.q_sf[0] B | self.q_sf S | self.q_sf[1] B | self.q_sf with eng_extract: S | q_extract[0] B | q_extract S | q_extract[1] B | q_extract # calculate final states for vectorize_mode= True matrix_extract = extract_unitary(eng_extract, cutoff_dim=self.D, vectorize_modes=True) final_state_extract = np.tile( matrix_extract.dot(initial_state.reshape([-1])), self.bsize) final_state_sf = self.eng_sf.run().ket().reshape([-1]) # calculate final states for vectorize_mode=False array_extract = extract_unitary(eng_extract, cutoff_dim=self.D, vectorize_modes=False) final_array_extract = np.einsum("abcd,bd->ac", array_extract, initial_state) final_array_sf = self.eng_sf.run().ket() self.assertAllAlmostEqual(final_state_extract, final_state_sf, delta=self.tol) self.assertAllAlmostEqual(final_array_extract, final_array_sf, delta=self.tol)
def setUp(self): """Set up.""" super().setUp() self.eng, q = sf.Engine(self.num_subsystems, hbar=self.hbar) self.eng.backend = self.backend cutoff = 7 if self.D < cutoff: logging.warning("Provided cutoff value is too small for " "tests in `PolyQuadExpectationMultiModeTests`. " "Cutoff has been increased internally.") self.D = cutoff self.backend.reset(cutoff_dim=self.D) if isinstance(self.backend, backends.TFBackend): raise unittest.SkipTest('The poly_quad_expectation method is not yet supported on the TF backend.')
def test_extract_channel_1_mode(self): """Test that channel extraction works for 1 mode""" self.logTestName() eng_extract, q_extract = sf.Engine(num_subsystems=1) S = sf.ops.Sgate(1.1, -1.4) L = sf.ops.LossChannel(0.45) initial_state = np.random.rand(self.D, self.D) with self.eng_sf: sf.ops.DensityMatrix(initial_state) | self.q_sf S | self.q_sf L | self.q_sf with eng_extract: S | q_extract L | q_extract choi = extract_channel(eng_extract, cutoff_dim=self.D, vectorize_modes=True, representation='choi') liouville = extract_channel(eng_extract, cutoff_dim=self.D, vectorize_modes=True, representation='liouville') kraus = extract_channel(eng_extract, cutoff_dim=self.D, vectorize_modes=True, representation='kraus') final_rho_sf = self.eng_sf.run().dm() final_rho_choi = np.einsum('abcd,ab -> cd', choi, initial_state) final_rho_liouville = np.einsum('abcd,db -> ca', liouville, initial_state) final_rho_kraus = np.einsum('abc,cd,aed -> be', kraus, initial_state, np.conj(kraus)) self.assertAllAlmostEqual(final_rho_choi, final_rho_sf, delta=self.tol) self.assertAllAlmostEqual(final_rho_liouville, final_rho_sf, delta=self.tol) self.assertAllAlmostEqual(final_rho_kraus, final_rho_sf, delta=self.tol)
def test_extract_unitary_2_modes_tf(self): """Test that unitary extraction works for 2 modes using the tf backend""" self.logTestName() eng_extract, q_extract = sf.Engine(num_subsystems=2) S = sf.ops.Sgate(2) B = sf.ops.BSgate(2.234, -1.165) initial_state = np.complex64( np.random.rand(self.D, self.D) + 1j * np.random.rand(self.D, self.D)) with self.eng_sf: sf.ops.Ket(initial_state) | (self.q_sf[0], self.q_sf[1]) S | self.q_sf[0] B | self.q_sf S | self.q_sf[1] B | self.q_sf with eng_extract: S | q_extract[0] B | q_extract S | q_extract[1] B | q_extract # calculate final states for vectorize_mode= True matrix_extract_tf_backend = extract_unitary(eng_extract, cutoff_dim=self.D, vectorize_modes=True, backend='tf') with tf.Session() as sess: sess.run(tf.global_variables_initializer()) final_state_tf_backend = sess.run( tf.einsum('ab,b', matrix_extract_tf_backend, tf.constant(initial_state.reshape([-1])))) final_state_tf_backend = np.tile(final_state_tf_backend, self.bsize) final_state_sf = self.eng_sf.run().ket().reshape([-1]) self.assertAllAlmostEqual(final_state_tf_backend, final_state_sf, delta=self.tol)
def test_extract_unitary_1_mode_tf(self): """Test that unitary extraction works for 1 mode using the tf backend""" self.logTestName() eng_extract, q_extract = sf.Engine(num_subsystems=1) S = sf.ops.Sgate(0.4, -1.2) D = sf.ops.Dgate(2, 0.9) K = sf.ops.Kgate(-1.5) initial_state = np.random.rand(self.D) + 1j * np.random.rand( self.D) # not a state but it doesn't matter with self.eng_sf: sf.ops.Ket(initial_state) | self.q_sf S | self.q_sf D | self.q_sf K | self.q_sf with eng_extract: S | q_extract D | q_extract K | q_extract matrix_extract_tf_backend = extract_unitary(eng_extract, cutoff_dim=self.D, backend='tf') with tf.Session() as sess: sess.run(tf.global_variables_initializer()) in_state = tf.constant(initial_state.reshape([-1]), dtype=tf.complex64) final_state_tf_backend = sess.run( tf.einsum('ab,b', matrix_extract_tf_backend, in_state)) final_state_sf = self.eng_sf.run().ket() self.assertAllAlmostEqual(final_state_tf_backend, final_state_sf, delta=self.tol)
def setUp(self): super().setUp() self.eng, q = sf.Engine(self.num_subsystems, hbar=self.hbar) self.eng.backend = self.backend self.eng.reset()
def setUp(self): super().setUp() self.eng, q = sf.Engine(self.num_subsystems, hbar=self.hbar)
def setUp(self): super().setUp() self.eng, q = sf.Engine(self.num_subsystems) # attach the backend (NOTE: self.backend is shared between the tests, make sure it is reset before use!) self.eng.backend = self.backend self.backend.reset(cutoff_dim=self.cutoff)
def setUp(self): super().setUp() self.eng, q = sf.Engine(self.num_subsystems) self.eng.backend = self.backend self.backend.reset(cutoff_dim=self.cutoff)
def test_extract_channel_2_modes_vectorize(self): """Test that channel extraction works for 2 modes vectorized""" self.logTestName() eng_extract, q_extract = sf.Engine(num_subsystems=2) S = sf.ops.Sgate(2) B = sf.ops.BSgate(2.234, -1.165) initial_state = np.random.rand( self.D, self.D, self.D, self.D) + 1j * np.random.rand(self.D, self.D, self.D, self.D) with self.eng_sf: sf.ops.DensityMatrix(initial_state) | (self.q_sf[0], self.q_sf[1]) S | self.q_sf[0] B | self.q_sf S | self.q_sf[1] B | self.q_sf with eng_extract: S | q_extract[0] B | q_extract S | q_extract[1] B | q_extract #vectorize = true choi = extract_channel(eng_extract, cutoff_dim=self.D, vectorize_modes=True, representation='choi') liouville = extract_channel(eng_extract, cutoff_dim=self.D, vectorize_modes=True, representation='liouville') kraus = extract_channel(eng_extract, cutoff_dim=self.D, vectorize_modes=True, representation='kraus') final_rho_sf = self.eng_sf.run().dm() if self.batched: final_rho_sf = final_rho_sf[0] final_rho_sf = np.einsum('abcd->acbd', final_rho_sf).reshape(self.D**2, self.D**2) initial_state = np.einsum('abcd->acbd', initial_state).reshape(self.D**2, self.D**2) final_rho_choi = np.einsum('abcd,ab -> cd', choi, initial_state) final_rho_liouville = np.einsum('abcd,db -> ca', liouville, initial_state) final_rho_kraus = np.einsum('abc,cd,aed -> be', kraus, initial_state, np.conj(kraus)) self.assertAllAlmostEqual(final_rho_choi, final_rho_sf, delta=self.tol) self.assertAllAlmostEqual(final_rho_liouville, final_rho_sf, delta=self.tol) self.assertAllAlmostEqual(final_rho_kraus, final_rho_sf, delta=self.tol)
def setUp(self): super().setUp() self.eng_sf, self.q_sf = sf.Engine(self.num_subsystems, hbar=self.hbar) self.eng_sf.backend = self.backend self.backend.reset(cutoff_dim=self.D)