Spaces:
Running
Running
| import random | |
| from sympy.core.numbers import (Integer, Rational) | |
| from sympy.core.singleton import S | |
| from sympy.core.symbol import symbols | |
| from sympy.functions.elementary.miscellaneous import sqrt | |
| from sympy.matrices.dense import Matrix | |
| from sympy.physics.quantum.qubit import (measure_all, measure_partial, | |
| matrix_to_qubit, matrix_to_density, | |
| qubit_to_matrix, IntQubit, | |
| IntQubitBra, QubitBra) | |
| from sympy.physics.quantum.gate import (HadamardGate, CNOT, XGate, YGate, | |
| ZGate, PhaseGate) | |
| from sympy.physics.quantum.qapply import qapply | |
| from sympy.physics.quantum.represent import represent | |
| from sympy.physics.quantum.shor import Qubit | |
| from sympy.testing.pytest import raises | |
| from sympy.physics.quantum.density import Density | |
| from sympy.physics.quantum.trace import Tr | |
| x, y = symbols('x,y') | |
| epsilon = .000001 | |
| def test_Qubit(): | |
| array = [0, 0, 1, 1, 0] | |
| qb = Qubit('00110') | |
| assert qb.flip(0) == Qubit('00111') | |
| assert qb.flip(1) == Qubit('00100') | |
| assert qb.flip(4) == Qubit('10110') | |
| assert qb.qubit_values == (0, 0, 1, 1, 0) | |
| assert qb.dimension == 5 | |
| for i in range(5): | |
| assert qb[i] == array[4 - i] | |
| assert len(qb) == 5 | |
| qb = Qubit('110') | |
| def test_QubitBra(): | |
| qb = Qubit(0) | |
| qb_bra = QubitBra(0) | |
| assert qb.dual_class() == QubitBra | |
| assert qb_bra.dual_class() == Qubit | |
| qb = Qubit(1, 1, 0) | |
| qb_bra = QubitBra(1, 1, 0) | |
| assert represent(qb, nqubits=3).H == represent(qb_bra, nqubits=3) | |
| qb = Qubit(0, 1) | |
| qb_bra = QubitBra(1,0) | |
| assert qb._eval_innerproduct_QubitBra(qb_bra) == Integer(0) | |
| qb_bra = QubitBra(0, 1) | |
| assert qb._eval_innerproduct_QubitBra(qb_bra) == Integer(1) | |
| def test_IntQubit(): | |
| # issue 9136 | |
| iqb = IntQubit(0, nqubits=1) | |
| assert qubit_to_matrix(Qubit('0')) == qubit_to_matrix(iqb) | |
| qb = Qubit('1010') | |
| assert qubit_to_matrix(IntQubit(qb)) == qubit_to_matrix(qb) | |
| iqb = IntQubit(1, nqubits=1) | |
| assert qubit_to_matrix(Qubit('1')) == qubit_to_matrix(iqb) | |
| assert qubit_to_matrix(IntQubit(1)) == qubit_to_matrix(iqb) | |
| iqb = IntQubit(7, nqubits=4) | |
| assert qubit_to_matrix(Qubit('0111')) == qubit_to_matrix(iqb) | |
| assert qubit_to_matrix(IntQubit(7, 4)) == qubit_to_matrix(iqb) | |
| iqb = IntQubit(8) | |
| assert iqb.as_int() == 8 | |
| assert iqb.qubit_values == (1, 0, 0, 0) | |
| iqb = IntQubit(7, 4) | |
| assert iqb.qubit_values == (0, 1, 1, 1) | |
| assert IntQubit(3) == IntQubit(3, 2) | |
| #test Dual Classes | |
| iqb = IntQubit(3) | |
| iqb_bra = IntQubitBra(3) | |
| assert iqb.dual_class() == IntQubitBra | |
| assert iqb_bra.dual_class() == IntQubit | |
| iqb = IntQubit(5) | |
| iqb_bra = IntQubitBra(5) | |
| assert iqb._eval_innerproduct_IntQubitBra(iqb_bra) == Integer(1) | |
| iqb = IntQubit(4) | |
| iqb_bra = IntQubitBra(5) | |
| assert iqb._eval_innerproduct_IntQubitBra(iqb_bra) == Integer(0) | |
| raises(ValueError, lambda: IntQubit(4, 1)) | |
| raises(ValueError, lambda: IntQubit('5')) | |
| raises(ValueError, lambda: IntQubit(5, '5')) | |
| raises(ValueError, lambda: IntQubit(5, nqubits='5')) | |
| raises(TypeError, lambda: IntQubit(5, bad_arg=True)) | |
| def test_superposition_of_states(): | |
| state = 1/sqrt(2)*Qubit('01') + 1/sqrt(2)*Qubit('10') | |
| state_gate = CNOT(0, 1)*HadamardGate(0)*state | |
| state_expanded = Qubit('01')/2 + Qubit('00')/2 - Qubit('11')/2 + Qubit('10')/2 | |
| assert qapply(state_gate).expand() == state_expanded | |
| assert matrix_to_qubit(represent(state_gate, nqubits=2)) == state_expanded | |
| #test apply methods | |
| def test_apply_represent_equality(): | |
| gates = [HadamardGate(int(3*random.random())), | |
| XGate(int(3*random.random())), ZGate(int(3*random.random())), | |
| YGate(int(3*random.random())), ZGate(int(3*random.random())), | |
| PhaseGate(int(3*random.random()))] | |
| circuit = Qubit(int(random.random()*2), int(random.random()*2), | |
| int(random.random()*2), int(random.random()*2), int(random.random()*2), | |
| int(random.random()*2)) | |
| for i in range(int(random.random()*6)): | |
| circuit = gates[int(random.random()*6)]*circuit | |
| mat = represent(circuit, nqubits=6) | |
| states = qapply(circuit) | |
| state_rep = matrix_to_qubit(mat) | |
| states = states.expand() | |
| state_rep = state_rep.expand() | |
| assert state_rep == states | |
| def test_matrix_to_qubits(): | |
| qb = Qubit(0, 0, 0, 0) | |
| mat = Matrix([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) | |
| assert matrix_to_qubit(mat) == qb | |
| assert qubit_to_matrix(qb) == mat | |
| state = 2*sqrt(2)*(Qubit(0, 0, 0) + Qubit(0, 0, 1) + Qubit(0, 1, 0) + | |
| Qubit(0, 1, 1) + Qubit(1, 0, 0) + Qubit(1, 0, 1) + | |
| Qubit(1, 1, 0) + Qubit(1, 1, 1)) | |
| ones = sqrt(2)*2*Matrix([1, 1, 1, 1, 1, 1, 1, 1]) | |
| assert matrix_to_qubit(ones) == state.expand() | |
| assert qubit_to_matrix(state) == ones | |
| def test_measure_normalize(): | |
| a, b = symbols('a b') | |
| state = a*Qubit('110') + b*Qubit('111') | |
| assert measure_partial(state, (0,), normalize=False) == \ | |
| [(a*Qubit('110'), a*a.conjugate()), (b*Qubit('111'), b*b.conjugate())] | |
| assert measure_all(state, normalize=False) == \ | |
| [(Qubit('110'), a*a.conjugate()), (Qubit('111'), b*b.conjugate())] | |
| def test_measure_partial(): | |
| #Basic test of collapse of entangled two qubits (Bell States) | |
| state = Qubit('01') + Qubit('10') | |
| assert measure_partial(state, (0,)) == \ | |
| [(Qubit('10'), S.Half), (Qubit('01'), S.Half)] | |
| assert measure_partial(state, int(0)) == \ | |
| [(Qubit('10'), S.Half), (Qubit('01'), S.Half)] | |
| assert measure_partial(state, (0,)) == \ | |
| measure_partial(state, (1,))[::-1] | |
| #Test of more complex collapse and probability calculation | |
| state1 = sqrt(2)/sqrt(3)*Qubit('00001') + 1/sqrt(3)*Qubit('11111') | |
| assert measure_partial(state1, (0,)) == \ | |
| [(sqrt(2)/sqrt(3)*Qubit('00001') + 1/sqrt(3)*Qubit('11111'), 1)] | |
| assert measure_partial(state1, (1, 2)) == measure_partial(state1, (3, 4)) | |
| assert measure_partial(state1, (1, 2, 3)) == \ | |
| [(Qubit('00001'), Rational(2, 3)), (Qubit('11111'), Rational(1, 3))] | |
| #test of measuring multiple bits at once | |
| state2 = Qubit('1111') + Qubit('1101') + Qubit('1011') + Qubit('1000') | |
| assert measure_partial(state2, (0, 1, 3)) == \ | |
| [(Qubit('1000'), Rational(1, 4)), (Qubit('1101'), Rational(1, 4)), | |
| (Qubit('1011')/sqrt(2) + Qubit('1111')/sqrt(2), S.Half)] | |
| assert measure_partial(state2, (0,)) == \ | |
| [(Qubit('1000'), Rational(1, 4)), | |
| (Qubit('1111')/sqrt(3) + Qubit('1101')/sqrt(3) + | |
| Qubit('1011')/sqrt(3), Rational(3, 4))] | |
| def test_measure_all(): | |
| assert measure_all(Qubit('11')) == [(Qubit('11'), 1)] | |
| state = Qubit('11') + Qubit('10') | |
| assert measure_all(state) == [(Qubit('10'), S.Half), | |
| (Qubit('11'), S.Half)] | |
| state2 = Qubit('11')/sqrt(5) + 2*Qubit('00')/sqrt(5) | |
| assert measure_all(state2) == \ | |
| [(Qubit('00'), Rational(4, 5)), (Qubit('11'), Rational(1, 5))] | |
| # from issue #12585 | |
| assert measure_all(qapply(Qubit('0'))) == [(Qubit('0'), 1)] | |
| def test_eval_trace(): | |
| q1 = Qubit('10110') | |
| q2 = Qubit('01010') | |
| d = Density([q1, 0.6], [q2, 0.4]) | |
| t = Tr(d) | |
| assert t.doit() == 1.0 | |
| # extreme bits | |
| t = Tr(d, 0) | |
| assert t.doit() == (0.4*Density([Qubit('0101'), 1]) + | |
| 0.6*Density([Qubit('1011'), 1])) | |
| t = Tr(d, 4) | |
| assert t.doit() == (0.4*Density([Qubit('1010'), 1]) + | |
| 0.6*Density([Qubit('0110'), 1])) | |
| # index somewhere in between | |
| t = Tr(d, 2) | |
| assert t.doit() == (0.4*Density([Qubit('0110'), 1]) + | |
| 0.6*Density([Qubit('1010'), 1])) | |
| #trace all indices | |
| t = Tr(d, [0, 1, 2, 3, 4]) | |
| assert t.doit() == 1.0 | |
| # trace some indices, initialized in | |
| # non-canonical order | |
| t = Tr(d, [2, 1, 3]) | |
| assert t.doit() == (0.4*Density([Qubit('00'), 1]) + | |
| 0.6*Density([Qubit('10'), 1])) | |
| # mixed states | |
| q = (1/sqrt(2)) * (Qubit('00') + Qubit('11')) | |
| d = Density( [q, 1.0] ) | |
| t = Tr(d, 0) | |
| assert t.doit() == (0.5*Density([Qubit('0'), 1]) + | |
| 0.5*Density([Qubit('1'), 1])) | |
| def test_matrix_to_density(): | |
| mat = Matrix([[0, 0], [0, 1]]) | |
| assert matrix_to_density(mat) == Density([Qubit('1'), 1]) | |
| mat = Matrix([[1, 0], [0, 0]]) | |
| assert matrix_to_density(mat) == Density([Qubit('0'), 1]) | |
| mat = Matrix([[0, 0], [0, 0]]) | |
| assert matrix_to_density(mat) == 0 | |
| mat = Matrix([[0, 0, 0, 0], | |
| [0, 0, 0, 0], | |
| [0, 0, 1, 0], | |
| [0, 0, 0, 0]]) | |
| assert matrix_to_density(mat) == Density([Qubit('10'), 1]) | |
| mat = Matrix([[1, 0, 0, 0], | |
| [0, 0, 0, 0], | |
| [0, 0, 0, 0], | |
| [0, 0, 0, 0]]) | |
| assert matrix_to_density(mat) == Density([Qubit('00'), 1]) | |