def test_generate_equivalent_ids_2(): # Test with Muls (x, y, z, h) = create_gate_sequence() assert generate_equivalent_ids((x, ), return_as_muls=True) == set([x]) gate_ids = set([Integer(1)]) assert generate_equivalent_ids(x * x, return_as_muls=True) == gate_ids gate_ids = set([x * y, y * x]) assert generate_equivalent_ids(x * y, return_as_muls=True) == gate_ids gate_ids = set([(x, y), (y, x)]) assert generate_equivalent_ids(x * y) == gate_ids circuit = Mul(*(x, y, z)) gate_ids = set( [x * y * z, y * z * x, z * x * y, z * y * x, y * x * z, x * z * y]) assert generate_equivalent_ids(circuit, return_as_muls=True) == gate_ids circuit = Mul(*(x, y, z, h)) gate_ids = set([ x * y * z * h, y * z * h * x, h * x * y * z, h * z * y * x, z * y * x * h, y * x * h * z, z * h * x * y, x * h * z * y ]) assert generate_equivalent_ids(circuit, return_as_muls=True) == gate_ids circuit = Mul(*(x, y, x, y)) gate_ids = set([x * y * x * y, y * x * y * x]) assert generate_equivalent_ids(circuit, return_as_muls=True) == gate_ids cgate_y = CGate((1, ), y) circuit = Mul(*(y, cgate_y, y, cgate_y)) gate_ids = set([y * cgate_y * y * cgate_y, cgate_y * y * cgate_y * y]) assert generate_equivalent_ids(circuit, return_as_muls=True) == gate_ids cnot = CNOT(1, 0) cgate_z = CGate((0, ), Z(1)) circuit = Mul(*(cnot, h, cgate_z, h)) gate_ids = set([ cnot * h * cgate_z * h, h * cgate_z * h * cnot, h * cnot * h * cgate_z, cgate_z * h * cnot * h ]) assert generate_equivalent_ids(circuit, return_as_muls=True) == gate_ids
def test_generate_equivalent_ids_1(): # Test with tuples (x, y, z, h) = create_gate_sequence() assert generate_equivalent_ids((x, )) == {(x, )} assert generate_equivalent_ids((x, x)) == {(x, x)} assert generate_equivalent_ids((x, y)) == {(x, y), (y, x)} gate_seq = (x, y, z) gate_ids = {(x, y, z), (y, z, x), (z, x, y), (z, y, x), (y, x, z), (x, z, y)} assert generate_equivalent_ids(gate_seq) == gate_ids gate_ids = { Mul(x, y, z), Mul(y, z, x), Mul(z, x, y), Mul(z, y, x), Mul(y, x, z), Mul(x, z, y) } assert generate_equivalent_ids(gate_seq, return_as_muls=True) == gate_ids gate_seq = (x, y, z, h) gate_ids = {(x, y, z, h), (y, z, h, x), (h, x, y, z), (h, z, y, x), (z, y, x, h), (y, x, h, z), (z, h, x, y), (x, h, z, y)} assert generate_equivalent_ids(gate_seq) == gate_ids gate_seq = (x, y, x, y) gate_ids = {(x, y, x, y), (y, x, y, x)} assert generate_equivalent_ids(gate_seq) == gate_ids cgate_y = CGate((1, ), y) gate_seq = (y, cgate_y, y, cgate_y) gate_ids = {(y, cgate_y, y, cgate_y), (cgate_y, y, cgate_y, y)} assert generate_equivalent_ids(gate_seq) == gate_ids cnot = CNOT(1, 0) cgate_z = CGate((0, ), Z(1)) gate_seq = (cnot, h, cgate_z, h) gate_ids = {(cnot, h, cgate_z, h), (h, cgate_z, h, cnot), (h, cnot, h, cgate_z), (cgate_z, h, cnot, h)} assert generate_equivalent_ids(gate_seq) == gate_ids
def test_random_insert(): x = X(0) y = Y(0) z = Z(0) h = H(0) cnot = CNOT(1, 0) cgate_z = CGate((0, ), Z(1)) seed = 1 choices = [(x, x)] circuit = (y, y) # insert location: 0; actual = random_insert(circuit, choices, seed=seed) assert actual == (x, x, y, y) seed = 8 circuit = (x, y, z, h) choices = [(h, h), (x, y, z)] expected = (x, x, y, z, y, z, h) # insert location: 1; circuit choice: 1 actual = random_insert(circuit, choices, seed=seed) assert actual == expected gate_list = [x, y, z, h, cnot, cgate_z] ids = list(bfs_identity_search(gate_list, 2, max_depth=4)) collapse_eq_ids = lambda acc, an_id: acc + list(an_id.equivalent_ids) eq_ids = reduce(collapse_eq_ids, ids, []) circuit = (x, y, h, cnot, cgate_z) expected = (x, y, z, y, z, y, h, cnot, cgate_z) # insert location: 1; circuit choice: 30 actual = random_insert(circuit, eq_ids, seed=seed) assert actual == expected circuit = Mul(*(x, y, h, cnot, cgate_z)) expected = (x, y, z, y, z, y, h, cnot, cgate_z) # insert location: 1; circuit choice: 30 actual = random_insert(circuit, eq_ids, seed=seed) assert actual == expected
def test_qasm_ex2(): q = Qasm('qubit q_0', 'qubit q_1', 'qubit q_2', 'h q_1', 'cnot q_1,q_2', 'cnot q_0,q_1', 'h q_0', 'measure q_1', 'measure q_0', 'c-x q_1,q_2', 'c-z q_0,q_2') assert q.get_circuit() == CGate(2, Z(0)) * CGate( 1, X(0)) * Mz(2) * Mz(1) * H(2) * CNOT(2, 1) * CNOT(1, 0) * H(1)
def test_qasm_swap(): q = Qasm('qubit q0', 'qubit q1', 'cnot q0,q1', 'cnot q1,q0', 'cnot q0,q1') assert q.get_circuit() == CNOT(1, 0) * CNOT(0, 1) * CNOT(1, 0)
def test_qasm_ex1(): q = Qasm('qubit q0', 'qubit q1', 'h q0', 'cnot q0,q1') assert q.get_circuit() == CNOT(1, 0) * H(1)
def test_cnot_commutators(): """Test commutators of involving CNOT gates.""" assert Commutator(CNOT(0, 1), Z(0)).doit() == 0 assert Commutator(CNOT(0, 1), T(0)).doit() == 0 assert Commutator(CNOT(0, 1), S(0)).doit() == 0 assert Commutator(CNOT(0, 1), X(1)).doit() == 0 assert Commutator(CNOT(0, 1), CNOT(0, 1)).doit() == 0 assert Commutator(CNOT(0, 1), CNOT(0, 2)).doit() == 0 assert Commutator(CNOT(0, 2), CNOT(0, 1)).doit() == 0 assert Commutator(CNOT(1, 2), CNOT(1, 0)).doit() == 0
def test_bfs_identity_search(): assert bfs_identity_search([], 1) == set() (x, y, z, h) = create_gate_sequence() gate_list = [x] id_set = {GateIdentity(x, x)} assert bfs_identity_search(gate_list, 1, max_depth=2) == id_set # Set should not contain degenerate quantum circuits gate_list = [x, y, z] id_set = { GateIdentity(x, x), GateIdentity(y, y), GateIdentity(z, z), GateIdentity(x, y, z) } assert bfs_identity_search(gate_list, 1) == id_set id_set = { GateIdentity(x, x), GateIdentity(y, y), GateIdentity(z, z), GateIdentity(x, y, z), GateIdentity(x, y, x, y), GateIdentity(x, z, x, z), GateIdentity(y, z, y, z) } assert bfs_identity_search(gate_list, 1, max_depth=4) == id_set assert bfs_identity_search(gate_list, 1, max_depth=5) == id_set gate_list = [x, y, z, h] id_set = { GateIdentity(x, x), GateIdentity(y, y), GateIdentity(z, z), GateIdentity(h, h), GateIdentity(x, y, z), GateIdentity(x, y, x, y), GateIdentity(x, z, x, z), GateIdentity(x, h, z, h), GateIdentity(y, z, y, z), GateIdentity(y, h, y, h) } assert bfs_identity_search(gate_list, 1) == id_set id_set = { GateIdentity(x, x), GateIdentity(y, y), GateIdentity(z, z), GateIdentity(h, h) } assert id_set == bfs_identity_search(gate_list, 1, max_depth=3, identity_only=True) id_set = { GateIdentity(x, x), GateIdentity(y, y), GateIdentity(z, z), GateIdentity(h, h), GateIdentity(x, y, z), GateIdentity(x, y, x, y), GateIdentity(x, z, x, z), GateIdentity(x, h, z, h), GateIdentity(y, z, y, z), GateIdentity(y, h, y, h), GateIdentity(x, y, h, x, h), GateIdentity(x, z, h, y, h), GateIdentity(y, z, h, z, h) } assert bfs_identity_search(gate_list, 1, max_depth=5) == id_set id_set = { GateIdentity(x, x), GateIdentity(y, y), GateIdentity(z, z), GateIdentity(h, h), GateIdentity(x, h, z, h) } assert id_set == bfs_identity_search(gate_list, 1, max_depth=4, identity_only=True) cnot = CNOT(1, 0) gate_list = [x, cnot] id_set = { GateIdentity(x, x), GateIdentity(cnot, cnot), GateIdentity(x, cnot, x, cnot) } assert bfs_identity_search(gate_list, 2, max_depth=4) == id_set cgate_x = CGate((1, ), x) gate_list = [x, cgate_x] id_set = { GateIdentity(x, x), GateIdentity(cgate_x, cgate_x), GateIdentity(x, cgate_x, x, cgate_x) } assert bfs_identity_search(gate_list, 2, max_depth=4) == id_set cgate_z = CGate((0, ), Z(1)) gate_list = [cnot, cgate_z, h] id_set = { GateIdentity(h, h), GateIdentity(cgate_z, cgate_z), GateIdentity(cnot, cnot), GateIdentity(cnot, h, cgate_z, h) } assert bfs_identity_search(gate_list, 2, max_depth=4) == id_set s = PhaseGate(0) t = TGate(0) gate_list = [s, t] id_set = {GateIdentity(s, s, s, s)} assert bfs_identity_search(gate_list, 1, max_depth=4) == id_set
def test_qasm_ex1(): q = Qasm("qubit q0", "qubit q1", "h q0", "cnot q0,q1") assert q.get_circuit() == CNOT(1, 0) * H(1)
def cnot(self, a1, a2): self.circuit.append(CNOT(*self.indices([a1, a2])))
""" qasm.py - Functions to parse a set of qasm commands into a Sympy Circuit. Examples taken from Chuang's page: http://www.media.mit.edu/quanta/qasm2circ/ The code returns a circuit and an associated list of labels. >>> from sympy.physics.quantum.qasm import Qasm >>> q = Qasm('qubit q0', 'qubit q1', 'h q0', 'cnot q0,q1') >>> q.get_circuit() CNOT(1,0)*H(1) >>> q = Qasm('qubit q0', 'qubit q1', 'cnot q0,q1', 'cnot q1,q0', 'cnot q0,q1') >>> q.get_circuit() CNOT(1,0)*CNOT(0,1)*CNOT(1,0) """ __all__ = [ "Qasm", ] from sympy.physics.quantum.gate import H, CNOT, X, Z, CGate, CGateS, SWAP, S, T, CPHASE from sympy.physics.quantum.circuitplot import Mz def read_qasm(lines): return Qasm(*lines.splitlines())
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
# Parameters # ---------- # label : tuple # A tuple of the form (control, target). # # ``` # # CNOTとSWAPを読み込みます。 # In[46]: from sympy.physics.quantum.gate import CNOT, SWAP # In[47]: represent(CNOT(1, 0), nqubits=2) # CNOTをそれぞれの2量子ビットに作用させてみます。 # In[48]: qapply(CNOT(1, 0) * q00) # In[49]: qapply(CNOT(1, 0) * q01) # In[50]: qapply(CNOT(1, 0) * q10)
def test_qasm_swap(): q = Qasm("qubit q0", "qubit q1", "cnot q0,q1", "cnot q1,q0", "cnot q0,q1") assert q.get_circuit() == CNOT(1, 0) * CNOT(0, 1) * CNOT(1, 0)
def test_convert_to_symbolic_indices(): (x, y, z, h) = create_gate_sequence() i0 = Symbol('i0') exp_map = {i0: Integer(0)} actual, act_map, sndx, gen = convert_to_symbolic_indices((x,)) assert actual == (X(i0),) assert act_map == exp_map expected = (X(i0), Y(i0), Z(i0), H(i0)) exp_map = {i0: Integer(0)} actual, act_map, sndx, gen = convert_to_symbolic_indices((x, y, z, h)) assert actual == expected assert exp_map == act_map (x1, y1, z1, h1) = create_gate_sequence(1) i1 = Symbol('i1') expected = (X(i0), Y(i0), Z(i0), H(i0)) exp_map = {i0: Integer(1)} actual, act_map, sndx, gen = convert_to_symbolic_indices((x1, y1, z1, h1)) assert actual == expected assert act_map == exp_map expected = (X(i0), Y(i0), Z(i0), H(i0), X(i1), Y(i1), Z(i1), H(i1)) exp_map = {i0: Integer(0), i1: Integer(1)} actual, act_map, sndx, gen = convert_to_symbolic_indices((x, y, z, h, x1, y1, z1, h1)) assert actual == expected assert act_map == exp_map exp_map = {i0: Integer(1), i1: Integer(0)} actual, act_map, sndx, gen = convert_to_symbolic_indices(Mul(x1, y1, z1, h1, x, y, z, h)) assert actual == expected assert act_map == exp_map expected = (X(i0), X(i1), Y(i0), Y(i1), Z(i0), Z(i1), H(i0), H(i1)) exp_map = {i0: Integer(0), i1: Integer(1)} actual, act_map, sndx, gen = convert_to_symbolic_indices(Mul(x, x1, y, y1, z, z1, h, h1)) assert actual == expected assert act_map == exp_map exp_map = {i0: Integer(1), i1: Integer(0)} actual, act_map, sndx, gen = convert_to_symbolic_indices((x1, x, y1, y, z1, z, h1, h)) assert actual == expected assert act_map == exp_map cnot_10 = CNOT(1, 0) cnot_01 = CNOT(0, 1) cgate_z_10 = CGate(1, Z(0)) cgate_z_01 = CGate(0, Z(1)) expected = (X(i0), X(i1), Y(i0), Y(i1), Z(i0), Z(i1), H(i0), H(i1), CNOT(i1, i0), CNOT(i0, i1), CGate(i1, Z(i0)), CGate(i0, Z(i1))) exp_map = {i0: Integer(0), i1: Integer(1)} args = (x, x1, y, y1, z, z1, h, h1, cnot_10, cnot_01, cgate_z_10, cgate_z_01) actual, act_map, sndx, gen = convert_to_symbolic_indices(args) assert actual == expected assert act_map == exp_map args = (x1, x, y1, y, z1, z, h1, h, cnot_10, cnot_01, cgate_z_10, cgate_z_01) expected = (X(i0), X(i1), Y(i0), Y(i1), Z(i0), Z(i1), H(i0), H(i1), CNOT(i0, i1), CNOT(i1, i0), CGate(i0, Z(i1)), CGate(i1, Z(i0))) exp_map = {i0: Integer(1), i1: Integer(0)} actual, act_map, sndx, gen = convert_to_symbolic_indices(args) assert actual == expected assert act_map == exp_map args = (cnot_10, h, cgate_z_01, h) expected = (CNOT(i0, i1), H(i1), CGate(i1, Z(i0)), H(i1)) exp_map = {i0: Integer(1), i1: Integer(0)} actual, act_map, sndx, gen = convert_to_symbolic_indices(args) assert actual == expected assert act_map == exp_map args = (cnot_01, h1, cgate_z_10, h1) exp_map = {i0: Integer(0), i1: Integer(1)} actual, act_map, sndx, gen = convert_to_symbolic_indices(args) assert actual == expected assert act_map == exp_map args = (cnot_10, h1, cgate_z_01, h1) expected = (CNOT(i0, i1), H(i0), CGate(i1, Z(i0)), H(i0)) exp_map = {i0: Integer(1), i1: Integer(0)} actual, act_map, sndx, gen = convert_to_symbolic_indices(args) assert actual == expected assert act_map == exp_map i2 = Symbol('i2') ccgate_z = CGate(0, CGate(1, Z(2))) ccgate_x = CGate(1, CGate(2, X(0))) args = (ccgate_z, ccgate_x) expected = (CGate(i0, CGate(i1, Z(i2))), CGate(i1, CGate(i2, X(i0)))) exp_map = {i0: Integer(0), i1: Integer(1), i2: Integer(2)} actual, act_map, sndx, gen = convert_to_symbolic_indices(args) assert actual == expected assert act_map == exp_map ndx_map = {i0: Integer(0)} index_gen = numbered_symbols(prefix='i', start=1) actual, act_map, sndx, gen = convert_to_symbolic_indices(args, qubit_map=ndx_map, start=i0, gen=index_gen) assert actual == expected assert act_map == exp_map i3 = Symbol('i3') cgate_x0_c321 = CGate((3, 2, 1), X(0)) exp_map = {i0: Integer(3), i1: Integer(2), i2: Integer(1), i3: Integer(0)} expected = (CGate((i0, i1, i2), X(i3)),) args = (cgate_x0_c321,) actual, act_map, sndx, gen = convert_to_symbolic_indices(args) assert actual == expected assert act_map == exp_map
def test_convert_to_real_indices(): i0 = Symbol('i0') i1 = Symbol('i1') (x, y, z, h) = create_gate_sequence() x_i0 = X(i0) y_i0 = Y(i0) z_i0 = Z(i0) qubit_map = {i0: 0} args = (z_i0, y_i0, x_i0) expected = (z, y, x) actual = convert_to_real_indices(args, qubit_map) assert actual == expected cnot_10 = CNOT(1, 0) cnot_01 = CNOT(0, 1) cgate_z_10 = CGate(1, Z(0)) cgate_z_01 = CGate(0, Z(1)) cnot_i1_i0 = CNOT(i1, i0) cnot_i0_i1 = CNOT(i0, i1) cgate_z_i1_i0 = CGate(i1, Z(i0)) qubit_map = {i0: 0, i1: 1} args = (cnot_i1_i0,) expected = (cnot_10,) actual = convert_to_real_indices(args, qubit_map) assert actual == expected args = (cgate_z_i1_i0,) expected = (cgate_z_10,) actual = convert_to_real_indices(args, qubit_map) assert actual == expected args = (cnot_i0_i1,) expected = (cnot_01,) actual = convert_to_real_indices(args, qubit_map) assert actual == expected qubit_map = {i0: 1, i1: 0} args = (cgate_z_i1_i0,) expected = (cgate_z_01,) actual = convert_to_real_indices(args, qubit_map) assert actual == expected i2 = Symbol('i2') ccgate_z = CGate(i0, CGate(i1, Z(i2))) ccgate_x = CGate(i1, CGate(i2, X(i0))) qubit_map = {i0: 0, i1: 1, i2: 2} args = (ccgate_z, ccgate_x) expected = (CGate(0, CGate(1, Z(2))), CGate(1, CGate(2, X(0)))) actual = convert_to_real_indices(Mul(*args), qubit_map) assert actual == expected qubit_map = {i0: 1, i2: 0, i1: 2} args = (ccgate_x, ccgate_z) expected = (CGate(2, CGate(0, X(1))), CGate(1, CGate(2, Z(0)))) actual = convert_to_real_indices(args, qubit_map) assert actual == expected
def get_sym_op(name, qid_tuple, params=None): """ return the sympy version for the gate Args: name (str): gate name qid_tuple (tuple): the ids of the qubits being operated on params (list): optional parameter lists, which may be needed by the U gates. Returns: object: (the sympy representation of) the gate being applied to the qubits Raises: Exception: if an unsupported operation is seen """ the_gate = None if name == 'ID': the_gate = IdentityGate(*qid_tuple) # de-tuple means unpacking elif name == 'X': the_gate = X(*qid_tuple) elif name == 'Y': the_gate = Y(*qid_tuple) elif name == 'Z': the_gate = Z(*qid_tuple) elif name == 'H': the_gate = H(*qid_tuple) elif name == 'S': the_gate = S(*qid_tuple) elif name == 'SDG': the_gate = SDGGate(*qid_tuple) elif name == 'T': the_gate = T(*qid_tuple) elif name == 'TDG': the_gate = TDGGate(*qid_tuple) elif name == 'CX' or name == 'CNOT': the_gate = CNOT(*qid_tuple) elif name == 'CY': the_gate = CGate(qid_tuple[0], Y(qid_tuple[1])) # qid_tuple: control target elif name == 'CZ': the_gate = CGate(qid_tuple[0], Z(qid_tuple[1])) # qid_tuple: control target elif name == 'CCX' or name == 'CCNOT' or name == 'TOFFOLI': the_gate = CGate((qid_tuple[0], qid_tuple[1]), X(qid_tuple[2])) if the_gate is not None: return the_gate # U gate, CU gate or measure gate handled below if name.startswith('U') or name.startswith('CU'): parameters = params if len(parameters) == 1: # [theta=0, phi=0, lambda] parameters.insert(0, 0.0) parameters.insert(0, 0.0) elif len(parameters) == 2: # [theta=pi/2, phi, lambda] parameters.insert(0, pi/2) elif len(parameters) == 3: # [theta, phi, lambda] pass else: raise Exception('U gate must carry 1, 2 or 3 parameters!') if name.startswith('U'): ugate = UGateGeneric(*qid_tuple) u_mat = compute_ugate_matrix(parameters) ugate.set_target_matrix(u_matrix=u_mat) return ugate elif name.startswith('CU'): # additional treatment for CU1, CU2, CU3 ugate = UGateGeneric(*qid_tuple) u_mat = compute_ugate_matrix(parameters) ugate.set_target_matrix(u_matrix=u_mat) return CGate(qid_tuple[0], ugate) elif name == "MEASURE": return None # if the control flow comes here, alarm! raise Exception('Not supported')