def test_purity_density_matrix(self): """Test purity function on density matrix inputs""" rho = DensityMatrix(np.diag([1, 0, 0, 0])) self.assertEqual(purity(rho), 1) self.assertEqual(purity(rho, validate=True), 1) self.assertEqual(purity(rho, validate=False), 1) rho = np.diag([0.25, 0.25, 0.25, 0.25]) self.assertEqual(purity(rho), 0.25) self.assertEqual(purity(rho, validate=True), 0.25) self.assertEqual(purity(rho, validate=False), 0.25) rho = [[0.5, 0, 0, 0.5], [0, 0, 0, 0], [0, 0, 0, 0], [0.5, 0, 0, 0.5]] self.assertEqual(purity(rho), 1) self.assertEqual(purity(rho, validate=True), 1) self.assertEqual(purity(rho, validate=False), 1) rho = np.diag([1, 0, 0, 1]) self.assertRaises(QiskitError, purity, rho) self.assertRaises(QiskitError, purity, rho, validate=True) self.assertEqual(purity(rho, validate=False), 2)
def test_tensor(self): """Test tensor method.""" rho0, rho1 = np.diag([1, 0]), np.diag([0, 1]) rho_init = DensityMatrix(np.kron(rho0, rho0)) chan1 = SuperOp(self.sopI) chan2 = SuperOp(self.sopX) # X \otimes I chan = chan2.tensor(chan1) rho_targ = DensityMatrix(np.kron(rho1, rho0)) self.assertEqual(chan.dim, (4, 4)) self.assertEqual(rho_init.evolve(chan), rho_targ) chan = chan2 ^ chan1 self.assertEqual(chan.dim, (4, 4)) self.assertEqual(rho_init.evolve(chan), rho_targ) # I \otimes X chan = chan1.tensor(chan2) rho_targ = DensityMatrix(np.kron(rho0, rho1)) self.assertEqual(chan.dim, (4, 4)) self.assertEqual(rho_init.evolve(chan), rho_targ) chan = chan1 ^ chan2 self.assertEqual(chan.dim, (4, 4)) self.assertEqual(rho_init.evolve(chan), rho_targ)
def test_multiple_registers(self): n = 4 q = QuantumRegister(n / 2) p = QuantumRegister(n / 2) qc = QuantumCircuit(q, p) qc.h(q[0]) qc.rx(np.pi / 4, q[1]) qc.cx(q[0], p[0]) qc.cx(q[1], p[1]) rho = DensityMatrix.from_instruction(qc).data measured_qubits = q #[q[0], q[1], q[2]] circ = pairwise_state_tomography_circuits(qc, measured_qubits) job = execute(circ, Aer.get_backend("qasm_simulator"), shots=nshots) fitter = PairwiseStateTomographyFitter(job.result(), circ, measured_qubits) result = fitter.fit() result_exp = fitter.fit(output='expectation') # Compare the tomography matrices with the partial trace of # the original state using fidelity for (k, v) in result.items(): trace_qubits = list(range(n)) trace_qubits.remove(measured_qubits[k[0]].index) trace_qubits.remove(measured_qubits[k[1]].index) rhok = partial_trace(rho, trace_qubits) try: self.check_density_matrix(v, rhok) except: print("Problem with density matrix:", k) raise try: self.check_pauli_expectaion(result_exp[k], rhok) except: print("Problem with expectation values:", k) raise
def test_meas_qubit_specification(self): n = 4 q = QuantumRegister(n) qc = QuantumCircuit(q) psi = ((2 * np.random.rand(2**n) - 1) + 1j * (2 * np.random.rand(2**n) - 1)) psi /= np.linalg.norm(psi) qc.initialize(psi, q) rho = DensityMatrix.from_instruction(qc).data measured_qubits = [q[0], q[2], q[3]] circ = pairwise_state_tomography_circuits(qc, measured_qubits) job = execute(circ, Aer.get_backend("qasm_simulator"), shots=nshots) fitter = PairwiseStateTomographyFitter(job.result(), circ, measured_qubits) result = fitter.fit() result_exp = fitter.fit(output='expectation') # Compare the tomography matrices with the partial trace of # the original state using fidelity for (k, v) in result.items(): #TODO: This method won't work if measured_qubits is not ordered in # wrt the DensityMatrix object. trace_qubits = list(range(n)) trace_qubits.remove(measured_qubits[k[0]].index) trace_qubits.remove(measured_qubits[k[1]].index) rhok = partial_trace(rho, trace_qubits) try: self.check_density_matrix(v, rhok) except: print("Problem with density matrix:", k) raise try: self.check_pauli_expectaion(result_exp[k], rhok) except: print("Problem with expectation values:", k) raise
def test_multiply(self): """Test multiply method.""" # Random initial state and Kraus ops rho = DensityMatrix(self.rand_rho(2)) val = 0.5 kraus1, kraus2 = self.rand_kraus(2, 4, 4), self.rand_kraus(2, 4, 4) # Single Kraus set chan1 = Kraus(kraus1) targ = val * (rho @ chan1) chan = chan1._multiply(val) self.assertEqual(rho @ chan, targ) chan = val * chan1 self.assertEqual(rho @ chan, targ) # Double Kraus set chan2 = Kraus((kraus1, kraus2)) targ = val * (rho @ chan2) chan = chan2._multiply(val) self.assertEqual(rho @ chan, targ) chan = val * chan2 self.assertEqual(rho @ chan, targ)
def test_sample_measure_qutrit(self): """Test sample measure method for qutrit state""" p = 0.3 shots = 1000 threshold = 0.02 * shots state = DensityMatrix(np.diag([p, 0, 1 - p])) state.seed(100) with self.subTest(msg='counts'): target = {'0': shots * p, '2': shots * (1 - p)} counts = state.sample_measure(shots=shots) self.assertDictAlmostEqual(counts, target, threshold) with self.subTest(msg='memory'): memory = state.sample_measure(shots=shots, memory=True) self.assertEqual(len(memory), shots) self.assertEqual(set(memory), set(['0', '2']))
def test_from_int(self): """Test from_int method""" with self.subTest(msg="from_int(0, 4)"): target = DensityMatrix([1, 0, 0, 0]) value = DensityMatrix.from_int(0, 4) self.assertEqual(target, value) with self.subTest(msg="from_int(3, 4)"): target = DensityMatrix([0, 0, 0, 1]) value = DensityMatrix.from_int(3, 4) self.assertEqual(target, value) with self.subTest(msg="from_int(8, (3, 3))"): target = DensityMatrix([0, 0, 0, 0, 0, 0, 0, 0, 1], dims=(3, 3)) value = DensityMatrix.from_int(8, (3, 3)) self.assertEqual(target, value)
def test_dot(self): """Test dot method.""" # Random input test state rho = DensityMatrix(self.rand_rho(2)) # UnitaryChannel evolution chan1 = Chi(self.chiX) chan2 = Chi(self.chiY) target = rho.evolve(Chi(self.chiZ)) output = rho.evolve(chan2.dot(chan1)) self.assertEqual(output, target) output = rho.evolve(chan2 * chan1) self.assertEqual(output, target) # Compose random chi1 = self.rand_matrix(4, 4, real=True) chi2 = self.rand_matrix(4, 4, real=True) chan1 = Chi(chi1, input_dims=2, output_dims=2) chan2 = Chi(chi2, input_dims=2, output_dims=2) target = rho.evolve(chan1).evolve(chan2) output = rho.evolve(chan2.dot(chan1)) self.assertEqual(output, target) output = rho.evolve(chan2 * chan1) self.assertEqual(output, target)
def test_expval(self): """Test expectation_value method""" psi = Statevector([1, 0, 0, 1]) / np.sqrt(2) rho = DensityMatrix(psi) for label, target in [ ("II", 1), ("XX", 1), ("YY", -1), ("ZZ", 1), ("IX", 0), ("YZ", 0), ("ZX", 0), ("YI", 0), ]: with self.subTest(msg=f"<{label}>"): op = Pauli(label) expval = rho.expectation_value(op) self.assertAlmostEqual(expval, target) psi = Statevector([np.sqrt(2), 0, 0, 0, 0, 0, 0, 1 + 1j]) / 2 rho = DensityMatrix(psi) for label, target in [ ("XXX", np.sqrt(2) / 2), ("YYY", -np.sqrt(2) / 2), ("ZZZ", 0), ("XYZ", 0), ("YIY", 0), ]: with self.subTest(msg=f"<{label}>"): op = Pauli(label) expval = rho.expectation_value(op) self.assertAlmostEqual(expval, target) labels = ["XXX", "IXI", "YYY", "III"] coeffs = [3.0, 5.5, -1j, 23] spp_op = SparsePauliOp.from_list(list(zip(labels, coeffs))) expval = rho.expectation_value(spp_op) target = 25.121320343559642 + 0.7071067811865476j self.assertAlmostEqual(expval, target)
def test_dot(self): """Test dot method.""" # Random input test state rho = DensityMatrix(self.rand_rho(2)) # UnitaryChannel evolution chan1 = PTM(self.ptmX) chan2 = PTM(self.ptmY) rho_targ = rho.evolve(PTM(self.ptmZ)) self.assertEqual(rho.evolve(chan2.dot(chan1)), rho_targ) # Compose random ptm1 = self.rand_matrix(4, 4, real=True) ptm2 = self.rand_matrix(4, 4, real=True) chan1 = PTM(ptm1, input_dims=2, output_dims=2) chan2 = PTM(ptm2, input_dims=2, output_dims=2) rho_targ = rho.evolve(chan1).evolve(chan2) self.assertEqual(rho.evolve(chan2.dot(chan1)), rho_targ)
def test_sub_qargs(self): """Test sub method with qargs.""" rho = DensityMatrix(self.rand_rho(8)) stine = self.rand_matrix(32, 8) stine0 = self.rand_matrix(8, 2) op = Stinespring(stine) op0 = Stinespring(stine0) eye = Stinespring(self.UI) with self.subTest(msg="qargs=[0]"): value = op - op0([0]) target = op - eye.tensor(eye).tensor(op0) self.assertEqual(rho & value, rho & target) with self.subTest(msg="qargs=[1]"): value = op - op0([1]) target = op - eye.tensor(op0).tensor(eye) self.assertEqual(rho & value, rho & target) with self.subTest(msg="qargs=[2]"): value = op - op0([2]) target = op - op0.tensor(eye).tensor(eye) self.assertEqual(rho & value, rho & target)
def test_entropy_density_matrix(self): """Test entropy function on density matrix inputs""" # Density matrix input rhos = [ DensityMatrix(np.diag([0.5] + (n * [0]) + [0.5])) for n in range(1, 5) ] for rho in rhos: self.assertAlmostEqual(entropy(rho), 1) self.assertAlmostEqual(entropy(rho, base=2), 1) self.assertAlmostEqual(entropy(rho, base=np.e), -1 * np.log(0.5)) # Array input for prob in [0.001, 0.3, 0.7, 0.999]: rho = np.diag([prob, 1 - prob]) self.assertAlmostEqual(entropy(rho), shannon_entropy([prob, 1 - prob])) self.assertAlmostEqual( entropy(rho, base=np.e), shannon_entropy([prob, 1 - prob], base=np.e)) self.assertAlmostEqual(entropy(rho, base=2), shannon_entropy([prob, 1 - prob], base=2)) # List input rho = [[0.5, 0], [0, 0.5]] self.assertAlmostEqual(entropy(rho), 1)
def test_add_qargs(self): """Test add method with qargs.""" rho = DensityMatrix(self.rand_rho(8)) stine = self.rand_matrix(32, 8) stine0 = self.rand_matrix(8, 2) op = Stinespring(stine) op0 = Stinespring(stine0) eye = Stinespring(self.UI) with self.subTest(msg='qargs=[0]'): value = op + op0([0]) target = op + eye.tensor(eye).tensor(op0) self.assertEqual(rho @ value, rho @ target) with self.subTest(msg='qargs=[1]'): value = op + op0([1]) target = op + eye.tensor(op0).tensor(eye) self.assertEqual(rho @ value, rho @ target) with self.subTest(msg='qargs=[2]'): value = op + op0([2]) target = op + op0.tensor(eye).tensor(eye) self.assertEqual(rho @ value, rho @ target)
def _bloch_multivector_data(state): """Return list of bloch vectors for each qubit Args: state (DensityMatrix or Statevector): an N-qubit state. Returns: list: list of bloch vectors (x, y, z) for each qubit. Raises: VisualizationError: if input is not an N-qubit state. """ rho = DensityMatrix(state) num = rho.num_qubits if num is None: raise VisualizationError("Input is not a multi-qubit quantum state.") pauli_singles = PauliTable.from_labels(['X', 'Y', 'Z']) bloch_data = [] for i in range(num): paulis = PauliTable(np.zeros((3, 2 * (num - 1)), dtype=np.bool)).insert( i, pauli_singles, qubit=True) bloch_state = [np.real(np.trace(np.dot(mat, rho.data))) for mat in paulis.matrix_iter()] bloch_data.append(bloch_state) return bloch_data
def test_add_qargs(self): """Test add method with qargs.""" rho = DensityMatrix(self.rand_rho(8)) kraus = self.rand_kraus(8, 8, 4) kraus0 = self.rand_kraus(2, 2, 4) op = Kraus(kraus) op0 = Kraus(kraus0) eye = Kraus(self.UI) with self.subTest(msg="qargs=[0]"): value = op + op0([0]) target = op + eye.tensor(eye).tensor(op0) self.assertEqual(rho & value, rho & target) with self.subTest(msg="qargs=[1]"): value = op + op0([1]) target = op + eye.tensor(op0).tensor(eye) self.assertEqual(rho & value, rho & target) with self.subTest(msg="qargs=[2]"): value = op + op0([2]) target = op + op0.tensor(eye).tensor(eye) self.assertEqual(rho & value, rho & target)
def test_sub_qargs(self): """Test sub method with qargs.""" rho = DensityMatrix(self.rand_rho(8)) kraus = self.rand_kraus(8, 8, 4) kraus0 = self.rand_kraus(2, 2, 4) op = Kraus(kraus) op0 = Kraus(kraus0) eye = Kraus(self.UI) with self.subTest(msg='qargs=[0]'): value = op - op0([0]) target = op - eye.tensor(eye).tensor(op0) self.assertEqual(rho @ value, rho @ target) with self.subTest(msg='qargs=[1]'): value = op - op0([1]) target = op - eye.tensor(op0).tensor(eye) self.assertEqual(rho @ value, rho @ target) with self.subTest(msg='qargs=[2]'): value = op - op0([2]) target = op - op0.tensor(eye).tensor(eye) self.assertEqual(rho @ value, rho @ target)
def test_sample_memory_w(self): """Test sample_memory method for W state""" shots = 3000 state = DensityMatrix( ( Statevector.from_label("001") + Statevector.from_label("010") + Statevector.from_label("100") ) / np.sqrt(3) ) state.seed(100) target = {"001": shots / 3, "010": shots / 3, "100": shots / 3} for qargs in [[0, 1, 2], [2, 1, 0], [1, 2, 0], [1, 0, 2]]: with self.subTest(msg=f"memory (qargs={qargs})"): memory = state.sample_memory(shots, qargs=qargs) self.assertEqual(len(memory), shots) self.assertEqual(set(memory), set(target)) # 2-qubit qargs target = {"00": shots / 3, "01": shots / 3, "10": shots / 3} for qargs in [[0, 1], [2, 1], [1, 2], [1, 2]]: with self.subTest(msg=f"memory (qargs={qargs})"): memory = state.sample_memory(shots, qargs=qargs) self.assertEqual(len(memory), shots) self.assertEqual(set(memory), set(target)) # 1-qubit qargs target = {"0": 2 * shots / 3, "1": shots / 3} for qargs in [[0], [1], [2]]: with self.subTest(msg=f"memory (qargs={qargs})"): memory = state.sample_memory(shots, qargs=qargs) self.assertEqual(len(memory), shots) self.assertEqual(set(memory), set(target))
def test_sample_counts_w(self): """Test sample_counts method for W state""" shots = 3000 threshold = 0.02 * shots state = DensityMatrix( ( Statevector.from_label("001") + Statevector.from_label("010") + Statevector.from_label("100") ) / np.sqrt(3) ) state.seed(100) target = {"001": shots / 3, "010": shots / 3, "100": shots / 3} for qargs in [[0, 1, 2], [2, 1, 0], [1, 2, 0], [1, 0, 2]]: with self.subTest(msg=f"P({qargs})"): counts = state.sample_counts(shots, qargs=qargs) self.assertDictAlmostEqual(counts, target, threshold) # 2-qubit qargs target = {"00": shots / 3, "01": shots / 3, "10": shots / 3} for qargs in [[0, 1], [2, 1], [1, 2], [1, 2]]: with self.subTest(msg=f"P({qargs})"): counts = state.sample_counts(shots, qargs=qargs) self.assertDictAlmostEqual(counts, target, threshold) # 1-qubit qargs target = {"0": 2 * shots / 3, "1": shots / 3} for qargs in [[0], [1], [2]]: with self.subTest(msg=f"P({qargs})"): counts = state.sample_counts(shots, qargs=qargs) self.assertDictAlmostEqual(counts, target, threshold)
def test_compose_front(self): """Test deprecated front compose method.""" # Random input test state rho = DensityMatrix(self.rand_rho(2)) # UnitaryChannel evolution chan1 = PTM(self.ptmX) chan2 = PTM(self.ptmY) chan = chan2.compose(chan1, front=True) rho_targ = rho.evolve(PTM(self.ptmZ)) self.assertEqual(rho.evolve(chan), rho_targ) # Compose random ptm1 = self.rand_matrix(4, 4, real=True) ptm2 = self.rand_matrix(4, 4, real=True) chan1 = PTM(ptm1, input_dims=2, output_dims=2) chan2 = PTM(ptm2, input_dims=2, output_dims=2) rho_targ = rho.evolve(chan1).evolve(chan2) chan = chan2.compose(chan1, front=True) self.assertEqual(chan.dim, (2, 2)) self.assertEqual(rho.evolve(chan), rho_targ)
def test_measure_qutrit(self): """Test measure method for qutrit""" state = DensityMatrix(np.diag([1, 1, 1]) / 3) seed = 200 shots = 100 for i in range(shots): rho = state.copy() rho.seed(seed + i) outcome, value = rho.measure() self.assertIn(outcome, ["0", "1", "2"]) if outcome == "0": target = DensityMatrix(np.diag([1, 0, 0])) self.assertEqual(value, target) elif outcome == "1": target = DensityMatrix(np.diag([0, 1, 0])) self.assertEqual(value, target) else: target = DensityMatrix(np.diag([0, 0, 1])) self.assertEqual(value, target)
def test_dot(self): """Test deprecated front compose method.""" # Random input test state rho_init = DensityMatrix(self.rand_rho(2)) # UnitaryChannel evolution chan1 = Stinespring(self.UX) chan2 = Stinespring(self.UY) rho_targ = rho_init.evolve(Stinespring(self.UZ)) self.assertEqual(rho_init.evolve(chan1.dot(chan2)), rho_targ) # 50% depolarizing channel chan1 = Stinespring(self.depol_stine(0.5)) rho_targ = rho_init & Stinespring(self.depol_stine(0.75)) self.assertEqual(rho_init.evolve(chan1.dot(chan1)), rho_targ) # Compose different dimensions stine1, stine2 = self.rand_matrix(16, 2), self.rand_matrix(8, 4) chan1 = Stinespring(stine1, input_dims=2, output_dims=4) chan2 = Stinespring(stine2, input_dims=4, output_dims=2) rho_targ = rho_init & chan1 & chan2 self.assertEqual(rho_init.evolve(chan2.dot(chan1)), rho_targ)
def test_multiply(self): """Test multiply method.""" # Random initial state and Stinespring ops rho_init = DensityMatrix(self.rand_rho(2)) val = 0.5 stine1, stine2 = self.rand_matrix(16, 2), self.rand_matrix(16, 2) # Single Stinespring set chan1 = Stinespring(stine1, input_dims=2, output_dims=4) rho_targ = val * (rho_init & chan1) chan = chan1._multiply(val) self.assertEqual(rho_init.evolve(chan), rho_targ) chan = val * chan1 self.assertEqual(rho_init.evolve(chan), rho_targ) # Double Stinespring set chan2 = Stinespring((stine1, stine2), input_dims=2, output_dims=4) rho_targ = val * (rho_init & chan2) chan = chan2._multiply(val) self.assertEqual(rho_init.evolve(chan), rho_targ) chan = val * chan2 self.assertEqual(rho_init.evolve(chan), rho_targ)
def test_dot(self): """Test dot method.""" # Random input test state rho = DensityMatrix(self.rand_rho(2)) # UnitaryChannel evolution chan1 = Kraus(self.UX) chan2 = Kraus(self.UY) targ = rho.evolve(Kraus(self.UZ)) self.assertEqual(rho.evolve(chan1.dot(chan2)), targ) # 50% depolarizing channel chan1 = Kraus(self.depol_kraus(0.5)) targ = rho & Kraus(self.depol_kraus(0.75)) self.assertEqual(rho.evolve(chan1.dot(chan1)), targ) # Compose different dimensions kraus1, kraus2 = self.rand_kraus(2, 4, 4), self.rand_kraus(4, 2, 4) chan1 = Kraus(kraus1) chan2 = Kraus(kraus2) targ = rho & chan1 & chan2 self.assertEqual(rho.evolve(chan2.dot(chan1)), targ)
def test_compose_front(self): """Test front compose method.""" # Random input test state rho = DensityMatrix(self.rand_rho(2)) # UnitaryChannel evolution chan1 = Chi(self.chiX) chan2 = Chi(self.chiY) chan = chan2.compose(chan1, front=True) target = rho.evolve(Chi(self.chiZ)) output = rho.evolve(chan) self.assertEqual(output, target) # Compose random chi1 = self.rand_matrix(4, 4, real=True) chi2 = self.rand_matrix(4, 4, real=True) chan1 = Chi(chi1, input_dims=2, output_dims=2) chan2 = Chi(chi2, input_dims=2, output_dims=2) target = rho.evolve(chan1).evolve(chan2) chan = chan2.compose(chan1, front=True) output = rho.evolve(chan) self.assertEqual(chan.dim, (2, 2)) self.assertEqual(output, target)
def test_negate(self): """Test negate method""" for _ in range(10): rho = self.rand_rho(4) state = DensityMatrix(rho) self.assertEqual(-state, DensityMatrix(-1 * rho))
def test_subtract_except(self): """Test subtract method raises exceptions.""" state1 = DensityMatrix(self.rand_rho(2)) state2 = DensityMatrix(self.rand_rho(3)) self.assertRaises(QiskitError, state1.subtract, state2)
def test_add_except(self): """Test add method raises exceptions.""" state1 = DensityMatrix(self.rand_rho(2)) state2 = DensityMatrix(self.rand_rho(3)) self.assertRaises(QiskitError, state1.add, state2)
def test_evolve_subsystem(self): """Test subsystem evolve method for operators.""" # Test evolving single-qubit of 3-qubit system for _ in range(5): rho = self.rand_rho(8) state = DensityMatrix(rho) op0 = random_unitary(2) op1 = random_unitary(2) op2 = random_unitary(2) # Test evolve on 1-qubit op = op0 op_full = Operator(np.eye(4)).tensor(op) target = DensityMatrix(np.dot(op_full.data, rho).dot(op_full.adjoint().data)) self.assertEqual(state.evolve(op, qargs=[0]), target) # Evolve on qubit 1 op_full = Operator(np.eye(2)).tensor(op).tensor(np.eye(2)) target = DensityMatrix(np.dot(op_full.data, rho).dot(op_full.adjoint().data)) self.assertEqual(state.evolve(op, qargs=[1]), target) # Evolve on qubit 2 op_full = op.tensor(np.eye(4)) target = DensityMatrix(np.dot(op_full.data, rho).dot(op_full.adjoint().data)) self.assertEqual(state.evolve(op, qargs=[2]), target) # Test evolve on 2-qubits op = op1.tensor(op0) # Evolve on qubits [0, 2] op_full = op1.tensor(np.eye(2)).tensor(op0) target = DensityMatrix(np.dot(op_full.data, rho).dot(op_full.adjoint().data)) self.assertEqual(state.evolve(op, qargs=[0, 2]), target) # Evolve on qubits [2, 0] op_full = op0.tensor(np.eye(2)).tensor(op1) target = DensityMatrix(np.dot(op_full.data, rho).dot(op_full.adjoint().data)) self.assertEqual(state.evolve(op, qargs=[2, 0]), target) # Test evolve on 3-qubits op = op2.tensor(op1).tensor(op0) # Evolve on qubits [0, 1, 2] op_full = op target = DensityMatrix(np.dot(op_full.data, rho).dot(op_full.adjoint().data)) self.assertEqual(state.evolve(op, qargs=[0, 1, 2]), target) # Evolve on qubits [2, 1, 0] op_full = op0.tensor(op1).tensor(op2) target = DensityMatrix(np.dot(op_full.data, rho).dot(op_full.adjoint().data)) self.assertEqual(state.evolve(op, qargs=[2, 1, 0]), target)
def test_rep(self): """Test Operator representation string property.""" state = DensityMatrix(self.rand_rho(2)) self.assertEqual(state.rep, 'DensityMatrix')
def test_equal(self): """Test __eq__ method""" for _ in range(10): rho = self.rand_rho(4) self.assertEqual(DensityMatrix(rho), DensityMatrix(rho.tolist()))