def _define(self): """ gate ccx a,b,c { h c; cx b,c; tdg c; cx a,c; t c; cx b,c; tdg c; cx a,c; t b; t c; h c; cx a,b; t a; tdg b; cx a,b;} """ # pylint: disable=cyclic-import from qiskit.circuit.quantumcircuit import QuantumCircuit q = QuantumRegister(3, 'q') qc = QuantumCircuit(q, name=self.name) rules = [ (HGate(), [q[2]], []), (CXGate(), [q[1], q[2]], []), (TdgGate(), [q[2]], []), (CXGate(), [q[0], q[2]], []), (TGate(), [q[2]], []), (CXGate(), [q[1], q[2]], []), (TdgGate(), [q[2]], []), (CXGate(), [q[0], q[2]], []), (TGate(), [q[1]], []), (TGate(), [q[2]], []), (HGate(), [q[2]], []), (CXGate(), [q[0], q[1]], []), (TGate(), [q[0]], []), (TdgGate(), [q[1]], []), (CXGate(), [q[0], q[1]], []) ] qc._data = rules self.definition = qc
def _define(self): """ gate ch a,b { s b; h b; t b; cx a, b; tdg b; h b; sdg b; } """ # pylint: disable=cyclic-import from qiskit.circuit.quantumcircuit import QuantumCircuit from .x import CXGate # pylint: disable=cyclic-import q = QuantumRegister(2, 'q') qc = QuantumCircuit(q, name=self.name) rules = [ (SGate(), [q[1]], []), (HGate(), [q[1]], []), (TGate(), [q[1]], []), (CXGate(), [q[0], q[1]], []), (TdgGate(), [q[1]], []), (HGate(), [q[1]], []), (SdgGate(), [q[1]], []) ] qc._data = rules self.definition = qc
def _define(self): """ gate rccx a,b,c { u2(0,pi) c; u1(pi/4) c; cx b, c; u1(-pi/4) c; cx a, c; u1(pi/4) c; cx b, c; u1(-pi/4) c; u2(0,pi) c; } """ # pylint: disable=cyclic-import from qiskit.circuit.quantumcircuit import QuantumCircuit q = QuantumRegister(3, 'q') qc = QuantumCircuit(q, name=self.name) rules = [ (U2Gate(0, pi), [q[2]], []), # H gate (U1Gate(pi / 4), [q[2]], []), # T gate (CXGate(), [q[1], q[2]], []), (U1Gate(-pi / 4), [q[2]], []), # inverse T gate (CXGate(), [q[0], q[2]], []), (U1Gate(pi / 4), [q[2]], []), (CXGate(), [q[1], q[2]], []), (U1Gate(-pi / 4), [q[2]], []), # inverse T gate (U2Gate(0, pi), [q[2]], []), # H gate ] qc._data = rules self.definition = qc
def _define(self): """ gate cu3(theta,phi,lambda) c, t { u1((lambda+phi)/2) c; u1((lambda-phi)/2) t; cx c,t; u3(-theta/2,0,-(phi+lambda)/2) t; cx c,t; u3(theta/2,phi,0) t; } """ # pylint: disable=cyclic-import from qiskit.circuit.quantumcircuit import QuantumCircuit from .u1 import U1Gate from .x import CXGate # pylint: disable=cyclic-import q = QuantumRegister(2, 'q') qc = QuantumCircuit(q, name=self.name) rules = [(U1Gate((self.params[2] + self.params[1]) / 2), [q[0]], []), (U1Gate((self.params[2] - self.params[1]) / 2), [q[1]], []), (CXGate(), [q[0], q[1]], []), (U3Gate(-self.params[0] / 2, 0, -(self.params[1] + self.params[2]) / 2), [q[1]], []), (CXGate(), [q[0], q[1]], []), (U3Gate(self.params[0] / 2, self.params[1], 0), [q[1]], [])] qc._data = rules self.definition = qc
def _define(self): # pylint: disable=cyclic-import from qiskit.circuit.quantumcircuit import QuantumCircuit from .u1 import U1Gate q = QuantumRegister(1, 'q') qc = QuantumCircuit(q, name=self.name) rules = [(U1Gate(pi), [q[0]], [])] qc._data = rules self.definition = qc
def _define(self): """ gate c3x a,b,c,d { h d; cu1(-pi/4) a,d; h d; cx a,b; h d; cu1(pi/4) b,d; h d; cx a,b; h d; cu1(-pi/4) b,d; h d; cx b,c; h d; cu1(pi/4) c,d; h d; cx a,c; h d; cu1(-pi/4) c,d; h d; cx b,c; h d; cu1(pi/4) c,d; h d; cx a,c; h d; cu1(-pi/4) c,d; h d; } """ # pylint: disable=cyclic-import from qiskit.circuit.quantumcircuit import QuantumCircuit from .u1 import CU1Gate q = QuantumRegister(4, name='q') rules = [ (HGate(), [q[3]], []), (CU1Gate(-self._angle), [q[0], q[3]], []), (HGate(), [q[3]], []), (CXGate(), [q[0], q[1]], []), (HGate(), [q[3]], []), (CU1Gate(self._angle), [q[1], q[3]], []), (HGate(), [q[3]], []), (CXGate(), [q[0], q[1]], []), (HGate(), [q[3]], []), (CU1Gate(-self._angle), [q[1], q[3]], []), (HGate(), [q[3]], []), (CXGate(), [q[1], q[2]], []), (HGate(), [q[3]], []), (CU1Gate(self._angle), [q[2], q[3]], []), (HGate(), [q[3]], []), (CXGate(), [q[0], q[2]], []), (HGate(), [q[3]], []), (CU1Gate(-self._angle), [q[2], q[3]], []), (HGate(), [q[3]], []), (CXGate(), [q[1], q[2]], []), (HGate(), [q[3]], []), (CU1Gate(self._angle), [q[2], q[3]], []), (HGate(), [q[3]], []), (CXGate(), [q[0], q[2]], []), (HGate(), [q[3]], []), (CU1Gate(-self._angle), [q[2], q[3]], []), (HGate(), [q[3]], []) ] qc = QuantumCircuit(q) qc._data = rules self.definition = qc
def _define(self): """ gate h a { u2(0,pi) a; } """ # pylint: disable=cyclic-import from qiskit.circuit.quantumcircuit import QuantumCircuit from .u2 import U2Gate q = QuantumRegister(1, 'q') qc = QuantumCircuit(q, name=self.name) rules = [(U2Gate(0, pi), [q[0]], [])] qc._data = rules self.definition = qc
def _define(self): """ gate dcx a, b { cx a, b; cx a, b; } """ # pylint: disable=cyclic-import from qiskit.circuit.quantumcircuit import QuantumCircuit from .x import CXGate q = QuantumRegister(2, 'q') qc = QuantumCircuit(q, name=self.name) rules = [(CXGate(), [q[0], q[1]], []), (CXGate(), [q[1], q[0]], [])] qc._data = rules self.definition = qc
def _define(self): # pylint: disable=cyclic-import from qiskit.circuit.quantumcircuit import QuantumCircuit from .rxx import RXXGate q = QuantumRegister(self.num_qubits, 'q') qc = QuantumCircuit(q, name=self.name) rules = [] for i in range(self.num_qubits): for j in range(i + 1, self.num_qubits): rules += [(RXXGate(self.params[0]), [q[i], q[j]], [])] qc._data = rules self.definition = qc
def _define(self): """ gate rx(theta) a {r(theta, 0) a;} """ # pylint: disable=cyclic-import from qiskit.circuit.quantumcircuit import QuantumCircuit from .r import RGate q = QuantumRegister(1, 'q') qc = QuantumCircuit(q, name=self.name) rules = [(RGate(self.params[0], 0), [q[0]], [])] qc._data = rules self.definition = qc
def _define(self): """ gate rz(phi) a { u1(phi) a; } """ # pylint: disable=cyclic-import from qiskit.circuit.quantumcircuit import QuantumCircuit from .u1 import U1Gate q = QuantumRegister(1, 'q') theta = self.params[0] qc = QuantumCircuit(q, name=self.name, global_phase=-theta / 2) rules = [(U1Gate(theta), [q[0]], [])] qc._data = rules self.definition = qc
def _define(self): """ gate rzx(theta) a, b { h b; cx a, b; u1(theta) b; cx a, b; h b;} """ # pylint: disable=cyclic-import from qiskit.circuit.quantumcircuit import QuantumCircuit q = QuantumRegister(2, 'q') qc = QuantumCircuit(q, name=self.name) rules = [(HGate(), [q[1]], []), (CXGate(), [q[0], q[1]], []), (RZGate(self.params[0]), [q[1]], []), (CXGate(), [q[0], q[1]], []), (HGate(), [q[1]], [])] qc._data = rules self.definition = qc
def _define(self): """ gate r(θ, φ) a {u3(θ, φ - π/2, -φ + π/2) a;} """ # pylint: disable=cyclic-import from qiskit.circuit.quantumcircuit import QuantumCircuit from .u3 import U3Gate q = QuantumRegister(1, 'q') qc = QuantumCircuit(q, name=self.name) theta = self.params[0] phi = self.params[1] rules = [(U3Gate(theta, phi - pi / 2, -phi + pi / 2), [q[0]], [])] qc._data = rules self.definition = qc
def _define(self): """ gate pauli (p1 a1,...,pn an) { p1 a1; ... ; pn an; } """ # pylint: disable=cyclic-import from qiskit.circuit.quantumcircuit import QuantumCircuit gates = {"I": IGate, "X": XGate, "Y": YGate, "Z": ZGate} q = QuantumRegister(len(self.params[0]), "q") qc = QuantumCircuit(q, name="{}({})".format(self.name, self.params[0])) rules = [(gates[p](), [q[i]], []) for (i, p) in enumerate(reversed(self.params[0]))] qc._data = rules self.definition = qc
def _define(self): # pylint: disable=cyclic-import from qiskit.circuit.quantumcircuit import QuantumCircuit q = QuantumRegister(self.num_qubits, 'q') qc = QuantumCircuit(q, name=self.name) if self.num_ctrl_qubits == 0: qc.p(self.params[0], 0) if self.num_ctrl_qubits == 1: qc.cp(self.params[0], 0, 1) else: from .u3 import _gray_code_chain scaled_lam = self.params[0] / (2 ** (self.num_ctrl_qubits - 1)) bottom_gate = CPhaseGate(scaled_lam) definition = _gray_code_chain(q, self.num_ctrl_qubits, bottom_gate) qc._data = definition self.definition = qc
def _define(self): """ gate c3sqrtx a,b,c,d { h d; cu1(-pi/8) a,d; h d; cx a,b; h d; cu1(pi/8) b,d; h d; cx a,b; h d; cu1(-pi/8) b,d; h d; cx b,c; h d; cu1(pi/8) c,d; h d; cx a,c; h d; cu1(-pi/8) c,d; h d; cx b,c; h d; cu1(pi/8) c,d; h d; cx a,c; h d; cu1(-pi/8) c,d; h d; } gate c4x a,b,c,d,e { h e; cu1(-pi/2) d,e; h e; c3x a,b,c,d; h d; cu1(pi/4) d,e; h d; c3x a,b,c,d; c3sqrtx a,b,c,e; } """ # pylint: disable=cyclic-import from qiskit.circuit.quantumcircuit import QuantumCircuit from .u1 import CU1Gate q = QuantumRegister(5, name='q') qc = QuantumCircuit(q, name=self.name) rules = [ (HGate(), [q[4]], []), (CU1Gate(-numpy.pi / 2), [q[3], q[4]], []), (HGate(), [q[4]], []), (C3XGate(), [q[0], q[1], q[2], q[3]], []), (HGate(), [q[4]], []), (CU1Gate(numpy.pi / 2), [q[3], q[4]], []), (HGate(), [q[4]], []), (C3XGate(), [q[0], q[1], q[2], q[3]], []), (C3XGate(numpy.pi / 8), [q[0], q[1], q[2], q[4]], []), ] qc._data = rules self.definition = qc
def _define(self): """ gate crz(lambda) a,b { u1(lambda/2) b; cx a,b; u1(-lambda/2) b; cx a,b; } """ # pylint: disable=cyclic-import from qiskit.circuit.quantumcircuit import QuantumCircuit from .u1 import U1Gate from .x import CXGate q = QuantumRegister(2, 'q') qc = QuantumCircuit(q, name=self.name) rules = [(U1Gate(self.params[0] / 2), [q[1]], []), (CXGate(), [q[0], q[1]], []), (U1Gate(-self.params[0] / 2), [q[1]], []), (CXGate(), [q[0], q[1]], [])] qc._data = rules self.definition = qc
def _define(self): """Calculate a subcircuit that implements this unitary.""" # pylint: disable=cyclic-import from qiskit.circuit.quantumcircuit import QuantumCircuit from .x import CXGate from .h import HGate from .rz import RZGate theta = self.params[0] q = QuantumRegister(2, 'q') qc = QuantumCircuit(q, name=self.name) rules = [ (HGate(), [q[0]], []), (HGate(), [q[1]], []), (CXGate(), [q[0], q[1]], []), (RZGate(theta), [q[1]], []), (CXGate(), [q[0], q[1]], []), (HGate(), [q[1]], []), (HGate(), [q[0]], []), ] qc._data = rules self.definition = qc
def _define(self): """ gate iswap a,b { s q[0]; s q[1]; h q[0]; cx q[0],q[1]; cx q[1],q[0]; h q[1]; } """ # pylint: disable=cyclic-import from qiskit.circuit.quantumcircuit import QuantumCircuit from .h import HGate from .s import SGate from .x import CXGate q = QuantumRegister(2, 'q') qc = QuantumCircuit(q, name=self.name) rules = [(SGate(), [q[0]], []), (SGate(), [q[1]], []), (HGate(), [q[0]], []), (CXGate(), [q[0], q[1]], []), (CXGate(), [q[1], q[0]], []), (HGate(), [q[1]], [])] qc._data = rules self.definition = qc
def _define(self): """Define the MCX gate using a V-chain of CX gates.""" # pylint: disable=cyclic-import from qiskit.circuit.quantumcircuit import QuantumCircuit q = QuantumRegister(self.num_qubits, name='q') qc = QuantumCircuit(q, name=self.name) q_controls = q[:self.num_ctrl_qubits] q_target = q[self.num_ctrl_qubits] q_ancillas = q[self.num_ctrl_qubits + 1:] definition = [] if self._dirty_ancillas: i = self.num_ctrl_qubits - 3 ancilla_pre_rule = [ (U2Gate(0, numpy.pi), [q_target], []), (CXGate(), [q_target, q_ancillas[i]], []), (U1Gate(-numpy.pi / 4), [q_ancillas[i]], []), (CXGate(), [q_controls[-1], q_ancillas[i]], []), (U1Gate(numpy.pi / 4), [q_ancillas[i]], []), (CXGate(), [q_target, q_ancillas[i]], []), (U1Gate(-numpy.pi / 4), [q_ancillas[i]], []), (CXGate(), [q_controls[-1], q_ancillas[i]], []), (U1Gate(numpy.pi / 4), [q_ancillas[i]], []), ] for inst in ancilla_pre_rule: definition.append(inst) for j in reversed(range(2, self.num_ctrl_qubits - 1)): definition.append( (RCCXGate(), [q_controls[j], q_ancillas[i - 1], q_ancillas[i]], [])) i -= 1 definition.append( (RCCXGate(), [q_controls[0], q_controls[1], q_ancillas[0]], [])) i = 0 for j in range(2, self.num_ctrl_qubits - 1): definition.append( (RCCXGate(), [q_controls[j], q_ancillas[i], q_ancillas[i + 1]], [])) i += 1 if self._dirty_ancillas: ancilla_post_rule = [ (U1Gate(-numpy.pi / 4), [q_ancillas[i]], []), (CXGate(), [q_controls[-1], q_ancillas[i]], []), (U1Gate(numpy.pi / 4), [q_ancillas[i]], []), (CXGate(), [q_target, q_ancillas[i]], []), (U1Gate(-numpy.pi / 4), [q_ancillas[i]], []), (CXGate(), [q_controls[-1], q_ancillas[i]], []), (U1Gate(numpy.pi / 4), [q_ancillas[i]], []), (CXGate(), [q_target, q_ancillas[i]], []), (U2Gate(0, numpy.pi), [q_target], []), ] for inst in ancilla_post_rule: definition.append(inst) else: definition.append( (CCXGate(), [q_controls[-1], q_ancillas[i], q_target], [])) for j in reversed(range(2, self.num_ctrl_qubits - 1)): definition.append( (RCCXGate(), [q_controls[j], q_ancillas[i - 1], q_ancillas[i]], [])) i -= 1 definition.append( (RCCXGate(), [q_controls[0], q_controls[1], q_ancillas[i]], [])) if self._dirty_ancillas: for i, j in enumerate(list(range(2, self.num_ctrl_qubits - 1))): definition.append( (RCCXGate(), [q_controls[j], q_ancillas[i], q_ancillas[i + 1]], [])) qc._data = definition self.definition = qc
def circuit_to_gate(circuit, parameter_map=None, equivalence_library=None, label=None): """Build a ``Gate`` object from a ``QuantumCircuit``. The gate is anonymous (not tied to a named quantum register), and so can be inserted into another circuit. The gate will have the same string name as the circuit. Args: circuit (QuantumCircuit): the input circuit. parameter_map (dict): For parameterized circuits, a mapping from parameters in the circuit to parameters to be used in the gate. If None, existing circuit parameters will also parameterize the Gate. equivalence_library (EquivalenceLibrary): Optional equivalence library where the converted gate will be registered. label (str): Optional gate label. Raises: QiskitError: if circuit is non-unitary or if parameter_map is not compatible with circuit Return: Gate: a Gate equivalent to the action of the input circuit. Upon decomposition, this gate will yield the components comprising the original circuit. """ # pylint: disable=cyclic-import from qiskit.circuit.quantumcircuit import QuantumCircuit if circuit.clbits: raise QiskitError('Circuit with classical bits cannot be converted ' 'to gate.') for inst, _, _ in circuit.data: if not isinstance(inst, Gate): raise QiskitError( ('One or more instructions cannot be converted to' ' a gate. "{}" is not a gate instruction').format(inst.name)) if parameter_map is None: parameter_dict = {p: p for p in circuit.parameters} else: parameter_dict = circuit._unroll_param_dict(parameter_map) if parameter_dict.keys() != circuit.parameters: raise QiskitError(('parameter_map should map all circuit parameters. ' 'Circuit parameters: {}, parameter_map: {}').format( circuit.parameters, parameter_dict)) gate = Gate(name=circuit.name, num_qubits=sum([qreg.size for qreg in circuit.qregs]), params=sorted(parameter_dict.values(), key=lambda p: p.name), label=label) gate.condition = None def find_bit_position(bit): """find the index of a given bit (Register, int) within a flat ordered list of bits of the circuit """ if isinstance(bit, Qubit): ordered_regs = circuit.qregs else: ordered_regs = circuit.cregs reg_index = ordered_regs.index(bit.register) return sum([reg.size for reg in ordered_regs[:reg_index]]) + bit.index target = circuit.assign_parameters(parameter_dict, inplace=False) if equivalence_library is not None: equivalence_library.add_equivalence(gate, target) rules = target.data if gate.num_qubits > 0: q = QuantumRegister(gate.num_qubits, 'q') # The 3rd parameter in the output tuple) is hard coded to [] because # Gate objects do not have cregs set and we've verified that all # instructions are gates rules = list( map( lambda x: (x[0], list(map(lambda y: q[find_bit_position(y)], x[1])), []), rules)) qc = QuantumCircuit(q, name=gate.name) qc._data = rules gate.definition = qc return gate
def circuit_to_instruction(circuit, parameter_map=None, equivalence_library=None): """Build an ``Instruction`` object from a ``QuantumCircuit``. The instruction is anonymous (not tied to a named quantum register), and so can be inserted into another circuit. The instruction will have the same string name as the circuit. Args: circuit (QuantumCircuit): the input circuit. parameter_map (dict): For parameterized circuits, a mapping from parameters in the circuit to parameters to be used in the instruction. If None, existing circuit parameters will also parameterize the instruction. equivalence_library (EquivalenceLibrary): Optional equivalence library where the converted instruction will be registered. Raises: QiskitError: if parameter_map is not compatible with circuit Return: qiskit.circuit.Instruction: an instruction equivalent to the action of the input circuit. Upon decomposition, this instruction will yield the components comprising the original circuit. Example: .. jupyter-execute:: from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit from qiskit.converters import circuit_to_instruction %matplotlib inline q = QuantumRegister(3, 'q') c = ClassicalRegister(3, 'c') circ = QuantumCircuit(q, c) circ.h(q[0]) circ.cx(q[0], q[1]) circ.measure(q[0], c[0]) circ.rz(0.5, q[1]).c_if(c, 2) circuit_to_instruction(circ) """ # pylint: disable=cyclic-import from qiskit.circuit.quantumcircuit import QuantumCircuit if parameter_map is None: parameter_dict = {p: p for p in circuit.parameters} else: parameter_dict = circuit._unroll_param_dict(parameter_map) if parameter_dict.keys() != circuit.parameters: raise QiskitError(('parameter_map should map all circuit parameters. ' 'Circuit parameters: {}, parameter_map: {}').format( circuit.parameters, parameter_dict)) instruction = Instruction( name=circuit.name, num_qubits=sum([qreg.size for qreg in circuit.qregs]), num_clbits=sum([creg.size for creg in circuit.cregs]), params=sorted(parameter_dict.values(), key=lambda p: p.name)) instruction.condition = None def find_bit_position(bit): """find the index of a given bit (Register, int) within a flat ordered list of bits of the circuit """ if isinstance(bit, Qubit): ordered_regs = circuit.qregs else: ordered_regs = circuit.cregs reg_index = ordered_regs.index(bit.register) return sum([reg.size for reg in ordered_regs[:reg_index]]) + bit.index target = circuit.assign_parameters(parameter_dict, inplace=False) if equivalence_library is not None: equivalence_library.add_equivalence(instruction, target) definition = target.data regs = [] if instruction.num_qubits > 0: q = QuantumRegister(instruction.num_qubits, 'q') regs.append(q) if instruction.num_clbits > 0: c = ClassicalRegister(instruction.num_clbits, 'c') regs.append(c) definition = list( map( lambda x: (x[0], list(map(lambda y: q[find_bit_position(y)], x[1])), list(map(lambda y: c[find_bit_position(y)], x[2]))), definition)) # fix condition for rule in definition: condition = rule[0].condition if condition: reg, val = condition if reg.size == c.size: rule[0].condition = (c, val) else: raise QiskitError( 'Cannot convert condition in circuit with ' 'multiple classical registers to instruction') qc = QuantumCircuit(*regs, name=instruction.name) qc._data = definition instruction.definition = qc return instruction