INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
gate ch a b { h b ; sdg b ; cx a b ; h b ; t b ; cx a b ; t b ; h b ; s b ; x b ; s a ; } | def _define(self):
"""
gate ch a,b {
h b;
sdg b;
cx a,b;
h b;
t b;
cx a,b;
t b;
h b;
s b;
x b;
s a;}
"""
definition = []
q = QuantumRegister(2, "q")
rule = [
(HGate(), [q[1... |
The backend configuration widget. | def config_tab(backend):
"""The backend configuration widget.
Args:
backend (IBMQbackend): The backend.
Returns:
grid: A GridBox widget.
"""
status = backend.status().to_dict()
config = backend.configuration().to_dict()
config_dict = {**status, **config}
upper_list = ... |
The qubits properties widget | def qubits_tab(backend):
"""The qubits properties widget
Args:
backend (IBMQbackend): The backend.
Returns:
VBox: A VBox widget.
"""
props = backend.properties().to_dict()
header_html = "<div><font style='font-weight:bold'>{key}</font>: {value}</div>"
header_html = header_... |
The multiple qubit gate error widget. | def gates_tab(backend):
"""The multiple qubit gate error widget.
Args:
backend (IBMQbackend): The backend.
Returns:
VBox: A VBox widget.
"""
config = backend.configuration().to_dict()
props = backend.properties().to_dict()
multi_qubit_gates = props['gates'][3*config['n_qub... |
Widget for displaying detailed noise map. | def detailed_map(backend):
"""Widget for displaying detailed noise map.
Args:
backend (IBMQbackend): The backend.
Returns:
GridBox: Widget holding noise map images.
"""
props = backend.properties().to_dict()
config = backend.configuration().to_dict()
single_gate_errors = [q... |
Widget for displaying job history | def job_history(backend):
"""Widget for displaying job history
Args:
backend (IBMQbackend): The backend.
Returns:
Tab: A tab widget for history images.
"""
year = widgets.Output(layout=widgets.Layout(display='flex-inline',
align_items='c... |
Plots the job history of the user from the given list of jobs. | def plot_job_history(jobs, interval='year'):
"""Plots the job history of the user from the given list of jobs.
Args:
jobs (list): A list of jobs with type IBMQjob.
interval (str): Interval over which to examine.
Returns:
fig: A Matplotlib figure instance.
"""
def get_date(j... |
Return a new circuit that has been optimized. | def run(self, dag):
"""Return a new circuit that has been optimized."""
resets = dag.op_nodes(Reset)
for reset in resets:
predecessor = next(dag.predecessors(reset))
if predecessor.type == 'in':
dag.remove_op_node(reset)
return dag |
Plot the interpolated envelope of pulse. | def draw(self, **kwargs):
"""Plot the interpolated envelope of pulse.
Keyword Args:
dt (float): Time interval of samples.
interp_method (str): Method of interpolation
(set `None` for turn off the interpolation).
filename (str): Name required to save p... |
Apply cu3 from ctl to tgt with angle theta phi lam. | def cu3(self, theta, phi, lam, ctl, tgt):
"""Apply cu3 from ctl to tgt with angle theta, phi, lam."""
return self.append(Cu3Gate(theta, phi, lam), [ctl, tgt], []) |
gate cu3 ( theta phi lambda ) c t { 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 ; } | def _define(self):
"""
gate cu3(theta,phi,lambda) c, t
{ 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;
}
"""
definition = []
q = QuantumRegister(2, "q")
rule = [
(U1Gate((self.p... |
Returns a circuit putting 2 qubits in the Bell state. | def build_bell_circuit():
"""Returns a circuit putting 2 qubits in the Bell state."""
q = QuantumRegister(2)
c = ClassicalRegister(2)
qc = QuantumCircuit(q, c)
qc.h(q[0])
qc.cx(q[0], q[1])
qc.measure(q, c)
return qc |
transpile one or more circuits according to some desired transpilation targets. | def transpile(circuits,
backend=None,
basis_gates=None, coupling_map=None, backend_properties=None,
initial_layout=None, seed_transpiler=None,
optimization_level=None,
pass_manager=None,
seed_mapper=None): # deprecated
"""transpile... |
Select a PassManager and run a single circuit through it. | def _transpile_circuit(circuit_config_tuple):
"""Select a PassManager and run a single circuit through it.
Args:
circuit_config_tuple (tuple):
circuit (QuantumCircuit): circuit to transpile
transpile_config (TranspileConfig): configuration dictating how to transpile
Returns... |
Resolve the various types of args allowed to the transpile () function through duck typing overriding args etc. Refer to the transpile () docstring for details on what types of inputs are allowed. | def _parse_transpile_args(circuits, backend,
basis_gates, coupling_map, backend_properties,
initial_layout, seed_transpiler, optimization_level,
pass_manager):
"""Resolve the various types of args allowed to the transpile() function throu... |
Execute a list of circuits or pulse schedules on a backend. | def execute(experiments, backend,
basis_gates=None, coupling_map=None, # circuit transpile options
backend_properties=None, initial_layout=None,
seed_transpiler=None, optimization_level=None, pass_manager=None,
qobj_id=None, qobj_header=None, shots=1024, # common run op... |
Return the primary drive channel of this qubit. | def drive(self) -> DriveChannel:
"""Return the primary drive channel of this qubit."""
if self._drives:
return self._drives[0]
else:
raise PulseError("No drive channels in q[%d]" % self._index) |
Return the primary control channel of this qubit. | def control(self) -> ControlChannel:
"""Return the primary control channel of this qubit."""
if self._controls:
return self._controls[0]
else:
raise PulseError("No control channels in q[%d]" % self._index) |
Return the primary measure channel of this qubit. | def measure(self) -> MeasureChannel:
"""Return the primary measure channel of this qubit."""
if self._measures:
return self._measures[0]
else:
raise PulseError("No measurement channels in q[%d]" % self._index) |
Return the primary acquire channel of this qubit. | def acquire(self) -> AcquireChannel:
"""Return the primary acquire channel of this qubit."""
if self._acquires:
return self._acquires[0]
else:
raise PulseError("No acquire channels in q[%d]" % self._index) |
n - qubit input state for QFT that produces output 1. | def input_state(circ, q, n):
"""n-qubit input state for QFT that produces output 1."""
for j in range(n):
circ.h(q[j])
circ.u1(math.pi/float(2**(j)), q[j]).inverse() |
Assembles a list of circuits into a qobj which can be run on the backend. | def assemble_circuits(circuits, qobj_id=None, qobj_header=None, run_config=None):
"""Assembles a list of circuits into a qobj which can be run on the backend.
Args:
circuits (list[QuantumCircuits]): circuit(s) to assemble
qobj_id (int): identifier for the generated qobj
qobj_header (Qob... |
Assembles a list of schedules into a qobj which can be run on the backend. Args: schedules ( list [ Schedule ] ): schedules to assemble qobj_id ( int ): identifier for the generated qobj qobj_header ( QobjHeader ): header to pass to the results run_config ( RunConfig ): configuration of the runtime environment Returns:... | def assemble_schedules(schedules, qobj_id=None, qobj_header=None, run_config=None):
"""Assembles a list of schedules into a qobj which can be run on the backend.
Args:
schedules (list[Schedule]): schedules to assemble
qobj_id (int): identifier for the generated qobj
qobj_header (QobjHead... |
Assemble a list of circuits or pulse schedules into a Qobj. | def assemble(experiments,
backend=None,
qobj_id=None, qobj_header=None, # common run options
shots=1024, memory=False, max_credits=None, seed_simulator=None,
default_qubit_los=None, default_meas_los=None, # schedule run options
schedule_los=None, meas_l... |
Resolve the various types of args allowed to the assemble () function through duck typing overriding args etc. Refer to the assemble () docstring for details on what types of inputs are allowed. | def _parse_run_args(backend, qobj_id, qobj_header,
shots, memory, max_credits, seed_simulator,
default_qubit_los, default_meas_los,
schedule_los, meas_level, meas_return,
memory_slots, memory_slot_size, rep_time,
paramet... |
Verifies that there is a single common set of parameters shared between all circuits and all parameter binds in the run_config. Returns an expanded list of circuits ( if parameterized ) with all parameters bound and a copy of the run_config with parameter_binds cleared. | def _expand_parameters(circuits, run_config):
"""Verifies that there is a single common set of parameters shared between
all circuits and all parameter binds in the run_config. Returns an expanded
list of circuits (if parameterized) with all parameters bound, and a copy of
the run_config with parameter_... |
Remove the handlers for the qiskit logger. | def unset_qiskit_logger():
"""Remove the handlers for the 'qiskit' logger."""
qiskit_logger = logging.getLogger('qiskit')
for handler in qiskit_logger.handlers:
qiskit_logger.removeHandler(handler) |
Create a hinton representation. | def iplot_state_hinton(rho, figsize=None):
""" Create a hinton representation.
Graphical representation of the input array using a 2D city style
graph (hinton).
Args:
rho (array): Density matrix
figsize (tuple): Figure size in pixels.
"""
# HTML
html_te... |
Return the process fidelity between two quantum channels. | def process_fidelity(channel1, channel2, require_cptp=True):
"""Return the process fidelity between two quantum channels.
This is given by
F_p(E1, E2) = Tr[S2^dagger.S1])/dim^2
where S1 and S2 are the SuperOp matrices for channels E1 and E2,
and dim is the dimension of the input output states... |
Set the input text data. | def input(self, data):
"""Set the input text data."""
self.data = data
self.lexer.input(data) |
Pop a PLY lexer off the stack. | def pop(self):
"""Pop a PLY lexer off the stack."""
self.lexer = self.stack.pop()
self.filename = self.lexer.qasm_file
self.lineno = self.lexer.qasm_line |
Push a PLY lexer on the stack to parse filename. | def push(self, filename):
"""Push a PLY lexer on the stack to parse filename."""
self.lexer.qasm_file = self.filename
self.lexer.qasm_line = self.lineno
self.stack.append(self.lexer)
self.__mklexer__(filename) |
include | def t_INCLUDE(self, t):
'include'
#
# Now eat up the next two tokens which must be
# 1 - the name of the include file, and
# 2 - a terminating semicolon
#
# Then push the current lexer onto the stack, create a new one from
# the include file, and push it o... |
r [ a - z ] [ a - zA - Z0 - 9_ ] * | def t_ID(self, t):
r'[a-z][a-zA-Z0-9_]*'
t.type = self.reserved.get(t.value, 'ID')
if t.type == 'ID':
t.value = node.Id(t.value, self.lineno, self.filename)
return t |
r \ n + | def t_newline(self, t):
r'\n+'
self.lineno += len(t.value)
t.lexer.lineno = self.lineno |
Create device specification with values in backend configuration. Args: backend ( Backend ): backend configuration Returns: DeviceSpecification: created device specification Raises: PulseError: when an invalid backend is specified | def create_from(cls, backend):
"""
Create device specification with values in backend configuration.
Args:
backend(Backend): backend configuration
Returns:
DeviceSpecification: created device specification
Raises:
PulseError: when an invalid ba... |
iterate over each block and replace it with an equivalent Unitary on the same wires. | def run(self, dag):
"""iterate over each block and replace it with an equivalent Unitary
on the same wires.
"""
new_dag = DAGCircuit()
for qreg in dag.qregs.values():
new_dag.add_qreg(qreg)
for creg in dag.cregs.values():
new_dag.add_creg(creg)
... |
Map each qubit in block_qargs to its wire position among the block s wires. Args: block_qargs ( list ): list of qubits that a block acts on global_index_map ( dict ): mapping from each qubit in the circuit to its wire position within that circuit Returns: dict: mapping from qarg to position in block | def _block_qargs_to_indices(self, block_qargs, global_index_map):
"""
Map each qubit in block_qargs to its wire position among the block's wires.
Args:
block_qargs (list): list of qubits that a block acts on
global_index_map (dict): mapping from each qubit in the
... |
Get conversion method for instruction. | def get_bound_method(self, instruction):
"""Get conversion method for instruction."""
try:
return self._bound_instructions[type(instruction)]
except KeyError:
raise PulseError('Qobj conversion method for %s is not found.' % instruction) |
Return converted AcquireInstruction. | def convert_acquire(self, shift, instruction):
"""Return converted `AcquireInstruction`.
Args:
shift(int): Offset time.
instruction (AcquireInstruction): acquire instruction.
Returns:
dict: Dictionary of required parameters.
"""
meas_level = s... |
Return converted FrameChangeInstruction. | def convert_frame_change(self, shift, instruction):
"""Return converted `FrameChangeInstruction`.
Args:
shift(int): Offset time.
instruction (FrameChangeInstruction): frame change instruction.
Returns:
dict: Dictionary of required parameters.
"""
... |
Return converted PersistentValueInstruction. | def convert_persistent_value(self, shift, instruction):
"""Return converted `PersistentValueInstruction`.
Args:
shift(int): Offset time.
instruction (PersistentValueInstruction): persistent value instruction.
Returns:
dict: Dictionary of required parameters.
... |
Return converted PulseInstruction. | def convert_drive(self, shift, instruction):
"""Return converted `PulseInstruction`.
Args:
shift(int): Offset time.
instruction (PulseInstruction): drive instruction.
Returns:
dict: Dictionary of required parameters.
"""
command_dict = {
... |
Return converted Snapshot. | def convert_snapshot(self, shift, instruction):
"""Return converted `Snapshot`.
Args:
shift(int): Offset time.
instruction (Snapshot): snapshot instruction.
Returns:
dict: Dictionary of required parameters.
"""
command_dict = {
'na... |
Update annotations of discretized continuous pulse function with duration. | def _update_annotations(discretized_pulse: Callable) -> Callable:
"""Update annotations of discretized continuous pulse function with duration.
Args:
discretized_pulse: Discretized decorated continuous pulse.
"""
undecorated_annotations = list(discretized_pulse.__annotations__.items())
deco... |
Update annotations of discretized continuous pulse function. | def _update_docstring(discretized_pulse: Callable, sampler_inst: Callable) -> Callable:
"""Update annotations of discretized continuous pulse function.
Args:
discretized_pulse: Discretized decorated continuous pulse.
sampler_inst: Applied sampler.
"""
wrapped_docstring = pydoc.render_do... |
Sampler decorator base method. | def sampler(sample_function: Callable) -> Callable:
"""Sampler decorator base method.
Samplers are used for converting an continuous function to a discretized pulse.
They operate on a function with the signature:
`def f(times: np.ndarray, *args, **kwargs) -> np.ndarray`
Where `times` is a nump... |
Return the backends matching the specified filtering. | def filter_backends(backends, filters=None, **kwargs):
"""Return the backends matching the specified filtering.
Filter the `backends` list by their `configuration` or `status`
attributes, or from a boolean callable. The criteria for filtering can
be specified via `**kwargs` or as a callable via `filter... |
Resolve backend name from a deprecated name or an alias. | def resolve_backend_name(name, backends, deprecated, aliased):
"""Resolve backend name from a deprecated name or an alias.
A group will be resolved in order of member priorities, depending on
availability.
Args:
name (str): name of backend to resolve
backends (list[BaseBackend]): list ... |
Build a QuantumCircuit object from a DAGCircuit. | def dag_to_circuit(dag):
"""Build a ``QuantumCircuit`` object from a ``DAGCircuit``.
Args:
dag (DAGCircuit): the input dag.
Return:
QuantumCircuit: the circuit representing the input dag.
"""
qregs = collections.OrderedDict()
for qreg in dag.qregs.values():
qreg_tmp = Q... |
Convert an observable in matrix form to dictionary form. | def make_dict_observable(matrix_observable):
"""Convert an observable in matrix form to dictionary form.
Takes in a diagonal observable as a matrix and converts it to a dictionary
form. Can also handle a list sorted of the diagonal elements.
Args:
matrix_observable (list): The observable to be... |
Update a node in the symbol table. | def update_symtab(self, obj):
"""Update a node in the symbol table.
Everything in the symtab must be a node with these attributes:
name - the string name of the object
type - the string type of the object
line - the source line where the type was first found
file - the s... |
Verify a qubit id against the gate prototype. | def verify_declared_bit(self, obj):
"""Verify a qubit id against the gate prototype."""
# We are verifying gate args against the formal parameters of a
# gate prototype.
if obj.name not in self.current_symtab:
raise QasmError("Cannot find symbol '" + obj.name
... |
Verify each expression in a list. | def verify_exp_list(self, obj):
"""Verify each expression in a list."""
# A tad harder. This is a list of expressions each of which could be
# the head of a tree. We need to recursively walk each of these and
# ensure that any Id elements resolve to the current stack.
#
... |
Verify a user defined gate call. | def verify_as_gate(self, obj, bitlist, arglist=None):
"""Verify a user defined gate call."""
if obj.name not in self.global_symtab:
raise QasmError("Cannot find gate definition for '" + obj.name
+ "', line", str(obj.line), 'file', obj.file)
g_sym = self.gl... |
Verify a register. | def verify_reg(self, obj, object_type):
"""Verify a register."""
# How to verify:
# types must match
# indexes must be checked
if obj.name not in self.global_symtab:
raise QasmError('Cannot find definition for', object_type, "'"
+ obj... |
Verify a list of registers. | def verify_reg_list(self, obj, object_type):
"""Verify a list of registers."""
# We expect the object to be a bitlist or an idlist, we don't care.
# We will iterate it and ensure everything in it is declared as a bit,
# and throw if not.
for children in obj.children:
... |
Return a list of ( name index ) tuples for this id node. | def id_tuple_list(self, id_node):
"""Return a list of (name, index) tuples for this id node."""
if id_node.type != "id":
raise QasmError("internal error, id_tuple_list")
bit_list = []
try:
g_sym = self.current_symtab[id_node.name]
except KeyError:
... |
Check that objects in list_of_nodes represent distinct ( qu ) bits. | def verify_distinct(self, list_of_nodes):
"""Check that objects in list_of_nodes represent distinct (qu)bits.
list_of_nodes is a list containing nodes of type id, indexed_id,
primary_list, or id_list. We assume these are all the same type
'qreg' or 'creg'.
This method raises an ... |
statement: decl | quantum_op ; | format ; | ignore | quantum_op error | format error | def p_statement(self, program):
"""
statement : decl
| quantum_op ';'
| format ';'
| ignore
| quantum_op error
| format error
"""
if len(program) > 2:
if program[2] != ... |
indexed_id: id [ NNINTEGER ] | id [ NNINTEGER error | id [ error | def p_indexed_id(self, program):
"""
indexed_id : id '[' NNINTEGER ']'
| id '[' NNINTEGER error
| id '[' error
"""
if len(program) == 4:
raise QasmError("Expecting an integer index; received",
str(prog... |
gate_id_list: id | def p_gate_id_list_0(self, program):
"""
gate_id_list : id
"""
program[0] = node.IdList([program[1]])
self.update_symtab(program[1]) |
gate_id_list: gate_id_list id | def p_gate_id_list_1(self, program):
"""
gate_id_list : gate_id_list ',' id
"""
program[0] = program[1]
program[0].add_child(program[3])
self.update_symtab(program[3]) |
bit_list: id | def p_bit_list_0(self, program):
"""
bit_list : id
"""
program[0] = node.IdList([program[1]])
program[1].is_bit = True
self.update_symtab(program[1]) |
bit_list: bit_list id | def p_bit_list_1(self, program):
"""
bit_list : bit_list ',' id
"""
program[0] = program[1]
program[0].add_child(program[3])
program[3].is_bit = True
self.update_symtab(program[3]) |
decl: qreg_decl ; | creg_decl ; | qreg_decl error | creg_decl error | gate_decl | def p_decl(self, program):
"""
decl : qreg_decl ';'
| creg_decl ';'
| qreg_decl error
| creg_decl error
| gate_decl
"""
if len(program) > 2:
if program[2] != ';':
raise QasmError("Missing ';' i... |
qreg_decl: QREG indexed_id | def p_qreg_decl(self, program):
"""
qreg_decl : QREG indexed_id
"""
program[0] = node.Qreg([program[2]])
if program[2].name in self.external_functions:
raise QasmError("QREG names cannot be reserved words. "
+ "Received '" + program[2].n... |
creg_decl: CREG indexed_id | def p_creg_decl(self, program):
"""
creg_decl : CREG indexed_id
"""
program[0] = node.Creg([program[2]])
if program[2].name in self.external_functions:
raise QasmError("CREG names cannot be reserved words. "
+ "Received '" + program[2].n... |
gate_decl: GATE id gate_scope ( ) bit_list gate_body | def p_gate_decl_1(self, program):
"""
gate_decl : GATE id gate_scope '(' ')' bit_list gate_body
"""
program[0] = node.Gate([program[2], program[6], program[7]])
if program[2].name in self.external_functions:
raise QasmError("GATE names cannot be reserved words. "
... |
gate_body: { } | def p_gate_body_0(self, program):
"""
gate_body : '{' '}'
"""
if program[2] != '}':
raise QasmError("Missing '}' in gate definition; received'"
+ str(program[2].value) + "'")
program[0] = node.GateBody(None) |
unitary_op: U ( exp_list ) primary | def p_unitary_op_0(self, program):
"""
unitary_op : U '(' exp_list ')' primary
"""
program[0] = node.UniversalUnitary([program[3], program[5]])
self.verify_reg(program[5], 'qreg')
self.verify_exp_list(program[3]) |
unitary_op: CX primary primary | def p_unitary_op_1(self, program):
"""
unitary_op : CX primary ',' primary
"""
program[0] = node.Cnot([program[2], program[4]])
self.verify_reg(program[2], 'qreg')
self.verify_reg(program[4], 'qreg')
self.verify_distinct([program[2], program[4]]) |
unitary_op: id primary_list | def p_unitary_op_2(self, program):
"""
unitary_op : id primary_list
"""
program[0] = node.CustomUnitary([program[1], program[2]])
self.verify_as_gate(program[1], program[2])
self.verify_reg_list(program[2], 'qreg')
self.verify_distinct([program[2]]) |
unitary_op: id ( ) primary_list | def p_unitary_op_3(self, program):
"""
unitary_op : id '(' ')' primary_list
"""
program[0] = node.CustomUnitary([program[1], program[4]])
self.verify_as_gate(program[1], program[4])
self.verify_reg_list(program[4], 'qreg')
self.verify_distinct([program[4]]) |
unitary_op: id ( exp_list ) primary_list | def p_unitary_op_4(self, program):
"""
unitary_op : id '(' exp_list ')' primary_list
"""
program[0] = node.CustomUnitary([program[1], program[3], program[5]])
self.verify_as_gate(program[1], program[5], arglist=program[3])
self.verify_reg_list(program[5], 'qreg')
... |
gate_op: U ( exp_list ) id ; | def p_gate_op_0(self, program):
"""
gate_op : U '(' exp_list ')' id ';'
"""
program[0] = node.UniversalUnitary([program[3], program[5]])
self.verify_declared_bit(program[5])
self.verify_exp_list(program[3]) |
gate_op: CX id id ; | def p_gate_op_1(self, program):
"""
gate_op : CX id ',' id ';'
"""
program[0] = node.Cnot([program[2], program[4]])
self.verify_declared_bit(program[2])
self.verify_declared_bit(program[4])
self.verify_distinct([program[2], program[4]]) |
gate_op: id id_list ; | def p_gate_op_2(self, program):
"""
gate_op : id id_list ';'
"""
program[0] = node.CustomUnitary([program[1], program[2]])
# To verify:
# 1. id is declared as a gate in global scope
# 2. everything in the id_list is declared as a bit in local scope
self.ve... |
gate_op: id ( ) id_list ; | def p_gate_op_3(self, program):
"""
gate_op : id '(' ')' id_list ';'
"""
program[0] = node.CustomUnitary([program[1], program[4]])
self.verify_as_gate(program[1], program[4])
self.verify_bit_list(program[4])
self.verify_distinct([program[4]]) |
gate_op: id ( exp_list ) id_list ; | def p_gate_op_4(self, program):
"""
gate_op : id '(' exp_list ')' id_list ';'
"""
program[0] = node.CustomUnitary([program[1], program[3], program[5]])
self.verify_as_gate(program[1], program[5], arglist=program[3])
self.verify_bit_list(program[5])
self.verify_exp... |
gate_op: BARRIER id_list ; | def p_gate_op_5(self, program):
"""
gate_op : BARRIER id_list ';'
"""
program[0] = node.Barrier([program[2]])
self.verify_bit_list(program[2])
self.verify_distinct([program[2]]) |
opaque: OPAQUE id gate_scope bit_list | def p_opaque_0(self, program):
"""
opaque : OPAQUE id gate_scope bit_list
"""
# TODO: Review Opaque function
program[0] = node.Opaque([program[2], program[4]])
if program[2].name in self.external_functions:
raise QasmError("OPAQUE names cannot be reserved w... |
opaque: OPAQUE id gate_scope ( ) bit_list | def p_opaque_1(self, program):
"""
opaque : OPAQUE id gate_scope '(' ')' bit_list
"""
program[0] = node.Opaque([program[2], program[6]])
self.pop_scope()
self.update_symtab(program[0]) |
measure: MEASURE primary ASSIGN primary | def p_measure(self, program):
"""
measure : MEASURE primary ASSIGN primary
"""
program[0] = node.Measure([program[2], program[4]])
self.verify_reg(program[2], 'qreg')
self.verify_reg(program[4], 'creg') |
barrier: BARRIER primary_list | def p_barrier(self, program):
"""
barrier : BARRIER primary_list
"""
program[0] = node.Barrier([program[2]])
self.verify_reg_list(program[2], 'qreg')
self.verify_distinct([program[2]]) |
reset: RESET primary | def p_reset(self, program):
"""
reset : RESET primary
"""
program[0] = node.Reset([program[2]])
self.verify_reg(program[2], 'qreg') |
if: IF ( id MATCHES NNINTEGER ) quantum_op if: IF ( id error if: IF ( id MATCHES error if: IF ( id MATCHES NNINTEGER error if: IF error | def p_if(self, program):
"""
if : IF '(' id MATCHES NNINTEGER ')' quantum_op
if : IF '(' id error
if : IF '(' id MATCHES error
if : IF '(' id MATCHES NNINTEGER error
if : IF error
"""
if len(program) == 3:
raise QasmError("Ill-formed IF stateme... |
unary: id ( expression ) | def p_unary_6(self, program):
"""
unary : id '(' expression ')'
"""
# note this is a semantic check, not syntactic
if program[1].name not in self.external_functions:
raise QasmError("Illegal external function call: ",
str(program[1].name... |
expression: - expression %prec negative | + expression %prec positive | def p_expression_1(self, program):
"""
expression : '-' expression %prec negative
| '+' expression %prec positive
"""
program[0] = node.Prefix([node.UnaryOperator(program[1]), program[2]]) |
expression: expression * expression | expression/ expression | expression + expression | expression - expression | expression ^ expression | def p_expression_0(self, program):
"""
expression : expression '*' expression
| expression '/' expression
| expression '+' expression
| expression '-' expression
| expression '^' expression
"""
program[0] = n... |
Compute the column. | def find_column(self, input_, token):
"""Compute the column.
Input is the input text string.
token is a token instance.
"""
if token is None:
return 0
last_cr = input_.rfind('\n', 0, token.lexpos)
if last_cr < 0:
last_cr = 0
column... |
Returns a generator of the tokens. | def get_tokens(self):
"""Returns a generator of the tokens."""
try:
while True:
token = self.lexer.token()
if not token:
break
yield token
except QasmError as e:
print('Exception tokenizing qasm file:',... |
Set the parse_deb field. | def parse_debug(self, val):
"""Set the parse_deb field."""
if val is True:
self.parse_deb = True
elif val is False:
self.parse_deb = False
else:
raise QasmError("Illegal debug value '" + str(val)
+ "' must be True or False."... |
Parse some data. | def parse(self, data):
"""Parse some data."""
self.parser.parse(data, lexer=self.lexer, debug=self.parse_deb)
if self.qasm is None:
raise QasmError("Uncaught exception in parser; "
+ "see previous messages for details.")
return self.qasm |
Parser runner. | def run(self, data):
"""Parser runner.
To use this module stand-alone.
"""
ast = self.parser.parse(data, debug=True)
self.parser.parse(data, debug=True)
ast.to_string(0) |
Returns a generator of the tokens. | def get_tokens(self):
"""Returns a generator of the tokens."""
if self._filename:
with open(self._filename) as ifile:
self._data = ifile.read()
with QasmParser(self._filename) as qasm_p:
return qasm_p.get_tokens() |
Parse the data. | def parse(self):
"""Parse the data."""
if self._filename:
with open(self._filename) as ifile:
self._data = ifile.read()
with QasmParser(self._filename) as qasm_p:
qasm_p.parse_debug(False)
return qasm_p.parse(self._data) |
Apply crz from ctl to tgt with angle theta. | def crz(self, theta, ctl, tgt):
"""Apply crz from ctl to tgt with angle theta."""
return self.append(CrzGate(theta), [ctl, tgt], []) |
Return a basis state ndarray. | def basis_state(str_state, num):
"""
Return a basis state ndarray.
Args:
str_state (string): a string representing the state.
num (int): the number of qubits
Returns:
ndarray: state(2**num) a quantum state with basis basis state.
Raises:
QiskitError: if the dimensi... |
maps a pure state to a state matrix | def projector(state, flatten=False):
"""
maps a pure state to a state matrix
Args:
state (ndarray): the number of qubits
flatten (bool): determine if state matrix of column work
Returns:
ndarray: state_mat(2**num, 2**num) if flatten is false
ndarray: state_mat(4**num) ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.