def _append_instruction(self, obj, qargs=None): """Update the current Statevector by applying an instruction.""" mat = Operator._instruction_to_matrix(obj) if mat is not None: # Perform the composition and inplace update the current state # of the operator self._data = self.evolve(mat, qargs=qargs).data else: # If the instruction doesn't have a matrix defined we use its # circuit decomposition definition if it exists, otherwise we # cannot compose this gate and raise an error. if obj.definition is None: raise QiskitError('Cannot apply Instruction: {}'.format( obj.name)) for instr, qregs, cregs in obj.definition: if cregs: raise QiskitError( 'Cannot apply instruction with classical registers: {}' .format(instr.name)) # Get the integer position of the flat register if qargs is None: new_qargs = [tup.index for tup in qregs] else: new_qargs = [qargs[tup.index] for tup in qregs] self._append_instruction(instr, qargs=new_qargs)
def _append_instruction(self, other, qargs=None): """Update the current Statevector by applying an instruction.""" # Try evolving by a matrix operator (unitary-like evolution) mat = Operator._instruction_to_matrix(other) if mat is not None: self._data = self._evolve_operator(Operator(mat), qargs=qargs).data return # Otherwise try evolving by a Superoperator chan = SuperOp._instruction_to_superop(other) if chan is not None: # Evolve current state by the superoperator self._data = chan._evolve(self, qargs=qargs).data return # If the instruction doesn't have a matrix defined we use its # circuit decomposition definition if it exists, otherwise we # cannot compose this gate and raise an error. if other.definition is None: raise QiskitError('Cannot apply Instruction: {}'.format( other.name)) for instr, qregs, cregs in other.definition: if cregs: raise QiskitError( 'Cannot apply instruction with classical registers: {}'. format(instr.name)) # Get the integer position of the flat register if qargs is None: new_qargs = [tup.index for tup in qregs] else: new_qargs = [qargs[tup.index] for tup in qregs] self._append_instruction(instr, qargs=new_qargs)
def _append_instruction(self, other, qargs=None): """Update the current Statevector by applying an instruction.""" from qiskit.circuit.reset import Reset from qiskit.circuit.barrier import Barrier # Try evolving by a matrix operator (unitary-like evolution) mat = Operator._instruction_to_matrix(other) if mat is not None: self._data = self._evolve_operator(Operator(mat), qargs=qargs).data return # Special instruction types if isinstance(other, Reset): self._data = self.reset(qargs)._data return if isinstance(other, Barrier): return # Otherwise try evolving by a Superoperator chan = SuperOp._instruction_to_superop(other) if chan is not None: # Evolve current state by the superoperator self._data = chan._evolve(self, qargs=qargs).data return # If the instruction doesn't have a matrix defined we use its # circuit decomposition definition if it exists, otherwise we # cannot compose this gate and raise an error. if other.definition is None: raise QiskitError(f"Cannot apply Instruction: {other.name}") if not isinstance(other.definition, QuantumCircuit): raise QiskitError( "{} instruction definition is {}; expected QuantumCircuit". format(other.name, type(other.definition))) qubit_indices = { bit: idx for idx, bit in enumerate(other.definition.qubits) } for instruction in other.definition: if instruction.clbits: raise QiskitError( f"Cannot apply instruction with classical bits: {instruction.operation.name}" ) # Get the integer position of the flat register if qargs is None: new_qargs = [qubit_indices[tup] for tup in instruction.qubits] else: new_qargs = [ qargs[qubit_indices[tup]] for tup in instruction.qubits ] self._append_instruction(instruction.operation, qargs=new_qargs)
def _evolve_instruction(statevec, obj, qargs=None): """Update the current Statevector by applying an instruction.""" from qiskit.circuit.reset import Reset from qiskit.circuit.barrier import Barrier mat = Operator._instruction_to_matrix(obj) if mat is not None: # Perform the composition and inplace update the current state # of the operator return Statevector._evolve_operator(statevec, Operator(mat), qargs=qargs) # Special instruction types if isinstance(obj, Reset): statevec._data = statevec.reset(qargs)._data return statevec if isinstance(obj, Barrier): return statevec # If the instruction doesn't have a matrix defined we use its # circuit decomposition definition if it exists, otherwise we # cannot compose this gate and raise an error. if obj.definition is None: raise QiskitError(f"Cannot apply Instruction: {obj.name}") if not isinstance(obj.definition, QuantumCircuit): raise QiskitError( "{} instruction definition is {}; expected QuantumCircuit". format(obj.name, type(obj.definition))) if obj.definition.global_phase: statevec._data *= np.exp(1j * float(obj.definition.global_phase)) qubits = {qubit: i for i, qubit in enumerate(obj.definition.qubits)} for instruction in obj.definition: if instruction.clbits: raise QiskitError( f"Cannot apply instruction with classical bits: {instruction.operation.name}" ) # Get the integer position of the flat register if qargs is None: new_qargs = [qubits[tup] for tup in instruction.qubits] else: new_qargs = [qargs[qubits[tup]] for tup in instruction.qubits] Statevector._evolve_instruction(statevec, instruction.operation, qargs=new_qargs) return statevec
def _evolve_instruction(statevec, obj, qargs=None): """Update the current Statevector by applying an instruction.""" from qiskit.circuit.reset import Reset from qiskit.circuit.barrier import Barrier mat = Operator._instruction_to_matrix(obj) if mat is not None: # Perform the composition and inplace update the current state # of the operator return Statevector._evolve_operator(statevec, Operator(mat), qargs=qargs) # Special instruction types if isinstance(obj, Reset): statevec._data = statevec.reset(qargs)._data return statevec if isinstance(obj, Barrier): return statevec # If the instruction doesn't have a matrix defined we use its # circuit decomposition definition if it exists, otherwise we # cannot compose this gate and raise an error. if obj.definition is None: raise QiskitError('Cannot apply Instruction: {}'.format(obj.name)) if not isinstance(obj.definition, QuantumCircuit): raise QiskitError( '{0} instruction definition is {1}; expected QuantumCircuit'. format(obj.name, type(obj.definition))) for instr, qregs, cregs in obj.definition: if cregs: raise QiskitError( 'Cannot apply instruction with classical registers: {}'. format(instr.name)) # Get the integer position of the flat register if qargs is None: new_qargs = [tup.index for tup in qregs] else: new_qargs = [qargs[tup.index] for tup in qregs] Statevector._evolve_instruction(statevec, instr, qargs=new_qargs) return statevec