def __init__(self, data, time, label=None): """Create a gate from a hamiltonian operator and evolution time parameter t Args: data (matrix or Operator): a hermitian operator. time (float): time evolution parameter. label (str): unitary name for backend [Default: None]. Raises: ExtensionError: if input data is not an N-qubit unitary operator. """ if hasattr(data, 'to_matrix'): # If input is Gate subclass or some other class object that has # a to_matrix method this will call that method. data = data.to_matrix() elif hasattr(data, 'to_operator'): # If input is a BaseOperator subclass this attempts to convert # the object to an Operator so that we can extract the underlying # numpy matrix from `Operator.data`. data = data.to_operator().data # Convert to numpy array in case not already an array data = numpy.array(data, dtype=complex) # Check input is unitary if not is_hermitian_matrix(data): raise ExtensionError("Input matrix is not Hermitian.") if isinstance(time, Number) and time != numpy.real(time): raise ExtensionError("Evolution time is not real.") # Check input is N-qubit matrix input_dim, output_dim = data.shape num_qubits = int(numpy.log2(input_dim)) if input_dim != output_dim or 2**num_qubits != input_dim: raise ExtensionError("Input matrix is not an N-qubit operator.") # Store instruction params super().__init__('hamiltonian', num_qubits, [data, time], label=label)
def __init__(self, data, label=None): """Create a gate from a numeric unitary matrix. Args: data (matrix or Operator): unitary operator. label (str): unitary name for backend [Default: None]. Raises: ExtensionError: if input data is not an N-qubit unitary operator. """ if hasattr(data, 'to_matrix'): # If input is Gate subclass or some other class object that has # a to_matrix method this will call that method. data = data.to_matrix() elif hasattr(data, 'to_operator'): # If input is a BaseOperator subclass this attempts to convert # the object to an Operator so that we can extract the underlying # numpy matrix from `Operator.data`. data = data.to_operator().data # Convert to numpy array in case not already an array data = numpy.array(data, dtype=complex) # Check input is unitary if not is_unitary_matrix(data): raise ExtensionError("Input matrix is not unitary.") # Check input is N-qubit matrix input_dim, output_dim = data.shape num_qubits = int(numpy.log2(input_dim)) if input_dim != output_dim or 2**num_qubits != input_dim: raise ExtensionError("Input matrix is not an N-qubit operator.") self._qasm_name = None self._qasm_definition = None self._qasm_def_written = False # Store instruction params super().__init__('unitary', num_qubits, [data], label=label)
def snapshot(self, label, snap_type='statevector'): """Take a snapshot of the internal simulator representation (statevector) Works on all qubits, and prevents reordering (like barrier). Args: label (str): a snapshot label to report the result snap_type (str): a snapshot type (only supports statevector) Returns: QuantumCircuit: with attached command Raises: ExtensionError: malformed command """ tuples = [] if isinstance(self, QuantumCircuit): for register in self.qregs: tuples.append(register) if not tuples: raise ExtensionError("no qubits for snapshot") if label is None: raise ExtensionError("no snapshot label passed") qubits = [] for tuple_element in tuples: if isinstance(tuple_element, QuantumRegister): for j in range(tuple_element.size): self._check_qubit((tuple_element, j)) qubits.append((tuple_element, j)) else: self._check_qubit(tuple_element) qubits.append(tuple_element) self._check_dups(qubits) return self._attach(Snapshot(label, snap_type, qubits, self))
def __init__(self, name, num_qubits, label, subtype='single', params=None): """Create new save data instruction. Args: name (str): the name of hte save instruction. num_qubits (int): the number of qubits for the snapshot type. label (str): the key for retrieving saved data from results. subtype (str): the data subtype for the instruction [Default: 'single']. params (list or None): Optional, the parameters for instruction [Default: None]. Raises: ExtensionError: if the subtype string is invalid. Additional Information: The supported subtypes are 'single', 'list', 'c_list', 'average', 'c_average', 'accum', 'c_accum'. """ if params is None: params = {} if subtype not in self._allowed_subtypes: raise ExtensionError( "Invalid data subtype for SaveData instruction.") if not isinstance(label, str): raise ExtensionError( f"Invalid label for save data instruction, {label} must be a string." ) self._label = label self._subtype = subtype super().__init__(name, num_qubits, 0, params)
def set_superop(self, state): """Set the superop state of the simulator. Args: state (QuantumChannel): A CPTP quantum channel. Returns: QuantumCircuit: with attached instruction. Raises: ExtensionError: If the state is the incorrect size for the current circuit. ExtensionError: if the input QuantumChannel is not CPTP. .. note: This instruction is always defined across all qubits in a circuit. """ qubits = default_qubits(self) if not isinstance(state, SuperOp): state = SuperOp(state) if not state.num_qubits or state.num_qubits != len(qubits): raise ExtensionError( "The size of the quantum channel for the set_superop" " instruction must be equal to the number of qubits" f" in the circuit (state.num_qubits ({state.num_qubits})" f" != QuantumCircuit.num_qubits ({self.num_qubits})).") return self.append(SetSuperOp(state), qubits)
def set_density_matrix(self, state): """Set the density matrix state of the simulator. Args: state (DensityMatrix): a density matrix. Returns: QuantumCircuit: with attached instruction. Raises: ExtensionError: If the density matrix is the incorrect size for the current circuit. .. note: This instruction is always defined across all qubits in a circuit. """ qubits = default_qubits(self) if not isinstance(state, DensityMatrix): state = DensityMatrix(state) if not state.num_qubits or state.num_qubits != len(qubits): raise ExtensionError( "The size of the density matrix for the set state" " instruction must be equal to the number of qubits" f" in the circuit (state.num_qubits ({state.num_qubits})" f" != QuantumCircuit.num_qubits ({self.num_qubits})).") return self.append(SetDensityMatrix(state), qubits)
def _expval_params(operator, variance=False): # Convert O to SparsePauliOp representation if isinstance(operator, Pauli): operator = SparsePauliOp(operator) elif not isinstance(operator, SparsePauliOp): operator = SparsePauliOp.from_operator(Operator(operator)) if not isinstance(operator, SparsePauliOp): raise ExtensionError("Invalid input operator") params = {} # Add Pauli basis components of O for pauli, coeff in operator.label_iter(): if pauli in params: coeff1 = params[pauli][0] params[pauli] = (coeff1 + coeff.real, 0) else: params[pauli] = (coeff.real, 0) # Add Pauli basis components of O^2 if variance: for pauli, coeff in operator.dot(operator).label_iter(): if pauli in params: coeff1, coeff2 = params[pauli] params[pauli] = (coeff1, coeff2 + coeff.real) else: params[pauli] = (0, coeff.real) # Convert to list return list(params.items())
def define_snapshot_register(circuit, label, qubits=None): """Defines qubits to snapshot for all snapshot methods""" # Convert label to string for backwards compatibility if not isinstance(label, str): warnings.warn( "Snapshot label should be a string, " "implicit conversion is deprecated.", DeprecationWarning) label = str(label) # If no qubits are specified we add all qubits so it acts as a barrier # This is needed for full register snapshots like statevector if isinstance(qubits, QuantumRegister): qubits = qubits[:] if not qubits: tuples = [] if isinstance(circuit, QuantumCircuit): for register in circuit.qregs: tuples.append(register) if not tuples: raise ExtensionError('no qubits for snapshot') qubits = [] for tuple_element in tuples: if isinstance(tuple_element, QuantumRegister): for j in range(tuple_element.size): qubits.append(tuple_element[j]) else: qubits.append(tuple_element) return qubits
def set_stabilizer(self, state): """Set the Clifford stabilizer state of the simulator. Args: state (Clifford): A clifford operator. Returns: QuantumCircuit: with attached instruction. Raises: ExtensionError: If the state is the incorrect size for the current circuit. .. note: This instruction is always defined across all qubits in a circuit. """ qubits = default_qubits(self) if not isinstance(state, Clifford): state = Clifford(state) if state.num_qubits != len(qubits): raise ExtensionError( "The size of the Clifford for the set_stabilizer" " instruction must be equal to the number of qubits" f" in the circuit (state.num_qubits ({state.num_qubits})" f" != QuantumCircuit.num_qubits ({self.num_qubits})).") return self.append(SetStabilizer(state), qubits)
def set_unitary(self, state): """Set the state state of the simulator. Args: state (Operator): A state matrix. Returns: QuantumCircuit: with attached instruction. Raises: ExtensionError: If the state is the incorrect size for the current circuit. ExtensionError: if the input matrix is not unitary. .. note: This instruction is always defined across all qubits in a circuit. """ qubits = default_qubits(self) if not isinstance(state, Operator): state = Operator(state) if not state.num_qubits or state.num_qubits != len(qubits): raise ExtensionError( "The size of the unitary matrix for the set_unitary" " instruction must be equal to the number of qubits" f" in the circuit (state.num_qubits ({state.num_qubits})" f" != QuantumCircuit.num_qubits ({self.num_qubits})).") return self.append(SetUnitary(state), qubits)
def define_snapshot_register(circuit, label=None, qubits=None): """Defines qubits to snapshot for all snapshot methods""" # Convert label to string for backwards compatibility if label is not None: warnings.warn( "The 'label' arg of `define_snapshot_register` has been deprecated" "as of qiskit-aer 0.7.0.", DeprecationWarning) # If no qubits are specified we add all qubits so it acts as a barrier # This is needed for full register snapshots like statevector if isinstance(qubits, QuantumRegister): qubits = qubits[:] if not qubits: tuples = [] if isinstance(circuit, QuantumCircuit): for register in circuit.qregs: tuples.append(register) if not tuples: raise ExtensionError('no qubits for snapshot') qubits = [] for tuple_element in tuples: if isinstance(tuple_element, QuantumRegister): for j in range(tuple_element.size): qubits.append(tuple_element[j]) else: qubits.append(tuple_element) return qubits
def __init__(self, label, snapshot_type='statevector', num_qubits=0, num_clbits=0, params=None): """Create new snapshot instruction. Args: label (str): the snapshot label for result data. snapshot_type (str): the type of the snapshot. num_qubits (int): the number of qubits for the snapshot type [Default: 0]. num_clbits (int): the number of classical bits for the snapshot type [Default: 0]. params (list or None): the parameters for snapshot_type [Default: None]. Raises: ExtensionError: if snapshot label is invalid. """ if not isinstance(label, str): raise ExtensionError('Snapshot label must be a string.') self._label = label self._snapshot_type = snapshot_type if params is None: params = [] super().__init__('snapshot', num_qubits, num_clbits, params)
def _format_amplitude_params(params, num_qubits=None): """Format amplitude params as a interger list.""" if isinstance(params[0], str): if params[0].find('0x') == 0: params = [int(i, 16) for i in params] else: params = [int(i, 2) for i in params] if num_qubits and max(params) >= 2 ** num_qubits: raise ExtensionError( "Param values contain a state larger than the number of qubits") return params
def __init__(self, label, op, single_shot=False, variance=False): """Create an expectation value snapshot instruction. Args: label (str): the snapshot label. op (Operator): operator to snapshot. single_shot (bool): return list for each shot rather than average [Default: False] variance (bool): compute variance of values [Default: False] Raises: ExtensionError: if snapshot is invalid. """ if variance: warn( 'The snapshot `variance` kwarg has been deprecated and will' ' be removed in qiskit-aer 0.8. To compute variance use' ' `single_shot=True` and compute manually in post-processing', DeprecationWarning) pauli_op = self._format_pauli_op(op) if pauli_op: # Pauli expectation value snapshot_type = 'expectation_value_pauli' params = pauli_op num_qubits = len(params[0][1]) else: snapshot_type = 'expectation_value_matrix' mat = self._format_single_matrix(op) if mat is not None: num_qubits = int(math.log2(len(mat))) if mat.shape != (2**num_qubits, 2**num_qubits): raise ExtensionError("Snapshot Operator is invalid.") qubits = list(range(num_qubits)) params = [[1., [[qubits, mat]]]] else: # If op doesn't match the previous cases we try passing # in the op as raw params params = op num_qubits = 0 for _, pair in params: num_qubits = max(num_qubits, *pair[0]) # HACK: we wrap param list in numpy array to make it validate # in terra params = [numpy.array(elt, dtype=object) for elt in params] if single_shot: snapshot_type += '_single_shot' elif variance: snapshot_type += '_with_variance' super().__init__(label, snapshot_type=snapshot_type, num_qubits=num_qubits, params=params)
def snapshot(self, label, snapshot_type='statevector', qubits=None, params=None): """Take a statevector snapshot of the internal simulator representation. Works on all qubits, and prevents reordering (like barrier). For other types of snapshots use the Snapshot extension directly. Args: label (str): a snapshot label to report the result snapshot_type (str): the type of the snapshot. qubits (list or None): the qubits to apply snapshot to [Default: None]. params (list or None): the parameters for snapshot_type [Default: None]. Returns: QuantumCircuit: with attached command Raises: ExtensionError: malformed command """ # Convert label to string for backwards compatibility if not isinstance(label, str): warnings.warn( "Snapshot label should be a string, " "implicit conversion is depreciated.", DeprecationWarning) label = str(label) # If no qubits are specified we add all qubits so it acts as a barrier # This is needed for full register snapshots like statevector if isinstance(qubits, QuantumRegister): qubits = qubits[:] if not qubits: tuples = [] if isinstance(self, QuantumCircuit): for register in self.qregs: tuples.append(register) if not tuples: raise ExtensionError('no qubits for snapshot') qubits = [] for tuple_element in tuples: if isinstance(tuple_element, QuantumRegister): for j in range(tuple_element.size): qubits.append(tuple_element[j]) else: qubits.append(tuple_element) return self.append( Snapshot( label, snapshot_type=snapshot_type, num_qubits=len(qubits), params=params), qubits)
def set_matrix_product_state(self, state): """Set the matrix product state of the simulator. Args: state (Tuple[List[Tuple[np.array[complex_t]]]], List[List[float]]): A matrix_product_state. Returns: QuantumCircuit: with attached instruction. Raises: ExtensionError: If the structure of the state is incorrect .. note: This instruction is always defined across all qubits in a circuit. """ qubits = default_qubits(self) if not isinstance(state, tuple) or len(state) != 2: raise ExtensionError( "The input matrix product state is not valid. Should be a list of 2 elements" ) if not isinstance(state[0], list) or not isinstance(state[1], list): raise ExtensionError( "The first element of the input matrix product state is not valid. Should be a list." ) if len(state[0]) != len(state[1]) + 1: raise ExtensionError( "The input matrix product state is not valid. " "Length of q_reg vector should be 1 more than length of lambda_reg" ) for elem in state[0]: if not isinstance(elem, tuple) or len(elem) != 2: raise ExtensionError( "The input matrix product state is not valid." "The first element should be a list of length 2") return self.append(SetMatrixProductState(state), qubits)
def __init__(self, operator, label="expectation_value_variance", unnormalized=False, pershot=False, conditional=False): r"""Instruction to save the expectation value and variance of a Hermitian operator. The expectation value of a Hermitian operator :math:`H` for a simulator in quantum state :math`\rho`is given by :math:`\langle H\rangle = \mbox{Tr}[H.\rho]`. The variance is given by :math:`\sigma^2 = \langle H^2 \rangle - \langle H \rangle>^2`. Args: operator (Pauli or SparsePauliOp or Operator): a Hermitian operator. label (str): the key for retrieving saved data from results. unnormalized (bool): If True return save the unnormalized accumulated or conditional accumulated expectation value over all shot [Default: False]. pershot (bool): if True save a list of expectation values for each shot of the simulation rather than the average over all shots [Default: False]. conditional (bool): if True save the average or pershot data conditional on the current classical register values [Default: False]. Raises: ExtensionError: if the input operator is invalid or not Hermitian. .. note:: This instruction can be directly appended to a circuit using the :func:`save_expectation_value` circuit method. """ # Convert O to SparsePauliOp representation if isinstance(operator, Pauli): operator = SparsePauliOp(operator) elif not isinstance(operator, SparsePauliOp): operator = SparsePauliOp.from_operator(Operator(operator)) if not allclose(operator.coeffs.imag, 0): raise ExtensionError("Input operator is not Hermitian.") params = _expval_params(operator, variance=True) super().__init__('save_expval_var', operator.num_qubits, label, unnormalized=unnormalized, pershot=pershot, conditional=conditional, params=params)
def control(self, num_ctrl_qubits=1, label=None, ctrl_state=None): r"""Return controlled version of gate Args: num_ctrl_qubits (int): number of controls to add to gate (default=1) label (str): optional gate label ctrl_state (int or str or None): The control state in decimal or as a bit string (e.g. '1011'). If None, use 2**num_ctrl_qubits-1. Returns: UnitaryGate: controlled version of gate. Raises: QiskitError: Invalid ctrl_state. ExtensionError: Non-unitary controlled unitary. """ cmat = _compute_control_matrix(self.to_matrix(), num_ctrl_qubits, ctrl_state=ctrl_state) iso = isometry.Isometry(cmat, 0, 0) cunitary = ControlledGate('c-unitary', num_qubits=self.num_qubits + num_ctrl_qubits, params=[cmat], label=label, num_ctrl_qubits=num_ctrl_qubits, definition=iso.definition, ctrl_state=ctrl_state) from qiskit.quantum_info import Operator # hack to correct global phase; should fix to prevent need for correction here pmat = (Operator(iso.inverse()).data @ cmat) diag = numpy.diag(pmat) if not numpy.allclose(diag, diag[0]): raise ExtensionError('controlled unitary generation failed') phase = numpy.angle(diag[0]) if phase: qreg = cunitary.definition.qregs[0] cunitary.definition.u3(numpy.pi, phase, phase - numpy.pi, qreg[0]) cunitary.definition.u3(numpy.pi, 0, numpy.pi, qreg[0]) cunitary.base_gate = self.copy() cunitary.base_gate.label = self.label return cunitary
def __init__(self, state): """Create new instruction to set the unitary simulator state. Args: state (Operator): A unitary matrix. Raises: ExtensionError: if the input matrix is not state. .. note:: This set instruction must always be performed on the full width of qubits in a circuit, otherwise an exception will be raised during simulation. """ if not isinstance(state, Operator): state = Operator(state) if not state.num_qubits or not state.is_unitary(): raise ExtensionError("The input matrix is not unitary") super().__init__('set_unitary', state.num_qubits, 0, [state.data])
def __init__(self, state): """Create new instruction to set the superop simulator state. Args: state (QuantumChannel): A CPTP quantum channel. Raises: ExtensionError: if the input QuantumChannel is not CPTP. .. note:: This set instruction must always be performed on the full width of qubits in a circuit, otherwise an exception will be raised during simulation. """ if not isinstance(state, SuperOp): state = SuperOp(state) if not state.num_qubits or not state.is_cptp(): raise ExtensionError("The input quantum channel is not CPTP") super().__init__('set_superop', state.num_qubits, 0, [state.data])
def __init__(self, state): """Create new instruction to set the statevector state of the simulator. Args: state (Statevector): a statevector. Raises: ExtensionError: if the input is not a valid state. .. note:: This set instruction must always be performed on the full width of qubits in a circuit, otherwise an exception will be raised during simulation. """ if not isinstance(state, Statevector): state = Statevector(state) if not state.num_qubits or not state.is_valid(): raise ExtensionError("The input statevector is not valid") super().__init__('set_statevector', state.num_qubits, 0, [state.data])
def control(self, num_ctrl_qubits=1, label=None, ctrl_state=None): """Return controlled version of gate Args: num_ctrl_qubits (int): number of controls to add to gate (default=1) label (str): optional gate label ctrl_state (int or str or None): The control state in decimal or as a bit string (e.g. '1011'). If None, use 2**num_ctrl_qubits-1. Returns: UnitaryGate: controlled version of gate. Raises: QiskitError: Invalid ctrl_state. ExtensionError: Non-unitary controlled unitary. """ mat = self.to_matrix() cmat = _compute_control_matrix(mat, num_ctrl_qubits, ctrl_state=None) iso = isometry.Isometry(cmat, 0, 0) cunitary = ControlledGate( "c-unitary", num_qubits=self.num_qubits + num_ctrl_qubits, params=[mat], label=label, num_ctrl_qubits=num_ctrl_qubits, definition=iso.definition, ctrl_state=ctrl_state, base_gate=self.copy(), ) from qiskit.quantum_info import Operator # hack to correct global phase; should fix to prevent need for correction here pmat = Operator(iso.inverse()).data @ cmat diag = numpy.diag(pmat) if not numpy.allclose(diag, diag[0]): raise ExtensionError("controlled unitary generation failed") phase = numpy.angle(diag[0]) if phase: # need to apply to _definition since open controls creates temporary definition cunitary._definition.global_phase = phase return cunitary
def __init__(self, state): """Create new instruction to set the density matrix state of the simulator. Args: state (DensityMatrix): a density matrix. Raises: ExtensionError: if the input density matrix is not valid. .. note:: This set instruction must always be performed on the full width of qubits in a circuit, otherwise an exception will be raised during simulation. """ if not isinstance(state, DensityMatrix): state = DensityMatrix(state) if not state.num_qubits or not state.is_valid(): raise ExtensionError("The input state is not valid") super().__init__('set_density_matrix', state.num_qubits, 0, [state.data])
def __init__(self, label, snapshot_type='statevector', num_qubits=0, num_clbits=0, params=None): """Create new snapshot instruction. Args: label (str): the snapshot label for result data. snapshot_type (str): the type of the snapshot. num_qubits (int): the number of qubits for the snapshot type [Default: 0]. num_clbits (int): the number of classical bits for the snapshot type [Default: 0]. params (list or None): the parameters for snapshot_type [Default: None]. Raises: ExtensionError: if snapshot label is invalid. .. deprecated:: 0.9.0 This instruction has been deprecated and will be removed no earlier than 3 months from the 0.9.0 release date. It has been superseded by the save instructions in :mod:`qiskit.providers.aer.library` module. """ warn( 'The `Snapshot` instruction will be deprecated in the' ' future. It has been superseded by the `SaveStatevector`' ' instructions.', DeprecationWarning, stacklevel=2) if not isinstance(label, str): raise ExtensionError('Snapshot label must be a string.') if params is None: params = [] super().__init__('snapshot', num_qubits, num_clbits, params) self._label = label self._snapshot_type = snapshot_type
def default_qubits(circuit, qubits=None): """Helper method to return list of qubits. Args: circuit (QuantumCircuit): a quantum circuit. qubits (list or QuantumRegister): Optional, qubits argument, If None the returned list will be all qubits in the circuit. [Default: None] Raises: ExtensionError: if default qubits fails. Returns: list: qubits list. """ # Convert label to string for backwards compatibility # If no qubits are specified we add all qubits so it acts as a barrier # This is needed for full register snapshots like statevector if isinstance(qubits, QuantumRegister): qubits = qubits[:] if not qubits: tuples = [] if isinstance(circuit, QuantumCircuit): for register in circuit.qregs: tuples.append(register) if not tuples: raise ExtensionError('no qubits for snapshot') qubits = [] for tuple_element in tuples: if isinstance(tuple_element, QuantumRegister): for j in range(tuple_element.size): qubits.append(tuple_element[j]) else: qubits.append(tuple_element) return qubits
def __init__(self, label, op, single_shot=False, variance=False): """Create an expectation value snapshot instruction. Args: label (str): the snapshot label. op (Operator): operator to snapshot. single_shot (bool): return list for each shot rather than average [Default: False] variance (bool): compute variance of values [Default: False] Raises: ExtensionError: if snapshot is invalid. .. deprecated:: 0.9.0 This instruction has been deprecated and will be removed no earlier than 3 months from the 0.9.0 release date. It has been superseded by the :class:`qiskit.providers.aer.library.SaveExpectationValue` and :class:`qiskit.providers.aer.library.SaveExpectationValueVariance` instructions. """ warn( 'The `SnapshotExpectationValue` instruction has been deprecated as of' ' qiskit-aer 0.9. It has been superseded by the `SaveExpectationValue` and' ' `SaveExpectationValueVariance` instructions.', DeprecationWarning, stacklevel=2) pauli_op = self._format_pauli_op(op) if pauli_op: # Pauli expectation value snapshot_type = 'expectation_value_pauli' params = pauli_op num_qubits = len(params[0][1]) else: snapshot_type = 'expectation_value_matrix' mat = self._format_single_matrix(op) if mat is not None: num_qubits = int(math.log2(len(mat))) if mat.shape != (2**num_qubits, 2**num_qubits): raise ExtensionError("Snapshot Operator is invalid.") qubits = list(range(num_qubits)) params = [[1., [[qubits, mat]]]] else: # If op doesn't match the previous cases we try passing # in the op as raw params params = op num_qubits = 0 for _, pair in params: num_qubits = max(num_qubits, *pair[0]) # HACK: we wrap param list in numpy array to make it validate # in terra params = [numpy.array(elt, dtype=object) for elt in params] if single_shot: snapshot_type += '_single_shot' elif variance: snapshot_type += '_with_variance' super().__init__(label, snapshot_type=snapshot_type, num_qubits=num_qubits, params=params)
def qasm(self): """Raise an error, as QASM is not defined for the HamiltonianGate.""" raise ExtensionError("HamiltonianGate as no QASM definition.")