def __init__(self, use_hardware=False, num_runs=1024, verbose=False,
user=None, password=None, device='ibmqx2'):
"""
Initialize the Backend object.
Args:
use_hardware (bool): If True, the code is run on the IBM quantum
chip (instead of using the IBM simulator)
num_runs (int): Number of runs to collect statistics.
(default is 1024)
verbose (bool): If True, statistics are printed, in addition to
the measurement result being registered (at the end of the
circuit).
user (string): IBM Quantum Experience user name
password (string): IBM Quantum Experience password
device (string): Device to use ('ibmqx2', 'ibmqx4', or 'ibmqx5')
if use_hardware is set to True. Default is ibmqx2.
"""
BasicEngine.__init__(self)
self._reset()
if use_hardware:
self.device = device
else:
self.device = 'simulator'
self._num_runs = num_runs
self._verbose = verbose
self._user = user
self._password = password
self._mapping = dict()
self._inverse_mapping = dict()
self._probabilities = dict()
self.qasm = ""
def __init__(self,
use_hardware=False,
num_runs=1024,
verbose=False,
user=None,
password=None):
"""
Initialize the Backend object.
Args:
use_hardware (bool): If True, the code is run on the IBM quantum chip
(instead of using the IBM simulator)
num_runs (int): Number of runs to collect statistics. (default is 1024)
verbose (bool): If True, statistics are printed, in addition to the
measurement result being registered (at the end of the circuit).
user (string): IBM Quantum Experience user name
password (string): IBM Quantum Experience password
"""
BasicEngine.__init__(self)
self._reset()
if use_hardware:
self._device = 'real'
else:
self._device = 'sim_trivial'
self._num_runs = num_runs
self._verbose = verbose
self._user = user
self._password = password
def __init__(self, accept_input=False, default_measure=0):
"""
Initialize a circuit drawing engine.
The TikZ code generator uses a settings file (settings.json), which
can be altered by the user. It contains gate widths, heights, offsets,
etc.
Args:
accept_input (bool): If accept_input is true, the printer queries
the user to input measurement results if the CircuitDrawer is
the last engine. Otherwise, all measurements yield the result
default_measure (0 or 1).
default_measure (bool): Default value to use as measurement
results if accept_input is False and there is no underlying
backend to register real measurement results.
"""
BasicEngine.__init__(self)
self._accept_input = accept_input
self._default_measure = default_measure
self._qubit_lines = dict()
self._free_lines = []
self._map = dict()
# Order in which qubit lines are drawn
self._drawing_order = []
def __init__(self,
decompositionRuleSet,
decomposition_chooser=lambda cmd, decomposition_list:
decomposition_list[0]):
"""
Initialize an AutoReplacer.
Args:
decomposition_chooser (function): A function which, given the
Command to decompose and a list of potential Decomposition
objects, determines (and then returns) the 'best'
decomposition.
The default decomposition chooser simply returns the first list
element, i.e., calling
.. code-block:: python
repl = AutoReplacer()
Amounts to
.. code-block:: python
def decomposition_chooser(cmd, decomp_list):
return decomp_list[0]
repl = AutoReplacer(decomposition_chooser)
"""
BasicEngine.__init__(self)
self._decomp_chooser = decomposition_chooser
self.decompositionRuleSet = decompositionRuleSet
def __init__(self, gate_fusion=False, rnd_seed=None): """ Construct the C++/Python-simulator object and initialize it with a random seed. Args: gate_fusion (bool): If True, gates are cached and only executed once a certain gate-size has been reached (only has an effect for the c++ simulator). rnd_seed (int): Random seed (uses random.randint(0, 1024) by default). Example of gate_fusion: Instead of applying a Hadamard gate to 5 qubits, the simulator calculates the kronecker product of the 1-qubit matrices and then applies 1 5-qubit gate. This increases operational intensity and keeps the simulator from having to iterate through the state vector multiple times. Depending on the system (and, especially, number of threads), this may or may not be beneficial. Note: If the C++ Simulator extension was not built or cannot be found, the Simulator defaults to a Python implementation of the kernels. While this is much slower, it is still good enough to run basic quantum algorithms. If you need to run large simulations, check out the tutorial in the docs which gives futher hints on how to build the C++ extension. """ if rnd_seed is None: rnd_seed = random.randint(0, 1024) BasicEngine.__init__(self) self._simulator = SimulatorBackend(rnd_seed) self._gate_fusion = gate_fusion
def __init__(
self,
outfile=None,
one_qubit_gate_map=None,
two_qubit_gate_map=None,
native_gates=None,
):
BasicEngine.__init__(self)
if native_gates is None:
from qscout.v1.std import NATIVE_GATES
native_gates = NATIVE_GATES
self._circuit = CircuitBuilder(native_gates=native_gates)
self._q = self._circuit.register("q", 0)
self._block = UnscheduledBlockBuilder()
self._circuit.expression.append(self._block.expression)
self._block.gate("prepare_all")
self.measure_accumulator = set()
self.reset_accumulator = set()
self.outfile = outfile
if one_qubit_gate_map is None:
self.one_qubit_gates = one_qubit_gates
else:
self.one_qubit_gates = one_qubit_gate_map
if two_qubit_gate_map is None:
self.two_qubit_gates = two_qubit_gates
else:
self.two_qubit_gates = two_qubit_gate_map
def __init__(self, cluster_size, num_global):
"""
Args:
cluster_size (int): The maximum number of qubits in fused
multi-qubit gate
num_global (int): Number of global qubits
"""
BasicEngine.__init__(self)
self._num_global = num_global
self._max_cluster_size = cluster_size
self._k_not_found = pow(2, 64) - 1
self._swaps = 0
self._swap_fraction = 0
self._runs = 0
self._gates = 0
self._last_gates = 0
self._locals = []
self._globals = [self._k_not_found] * num_global
self._cluster = set()
self._is_diag_cluster = True
self._is_empty_cluster = True
self._nothing = True
self._simulator = FakeSimulator()
self._dealloc = False
def __init__(
self,
num_runs: int = 1024,
verbose: int = 0,
quantum_inspire_api: Optional[QuantumInspireAPI] = None,
backend_type: Optional[Union[Dict[str, Any], int,
str]] = None) -> None:
"""
Initialize the Backend object.
Args:
num_runs: Number of runs to collect statistics (default is 1024).
verbose: Verbosity level, defaults to 0, which produces no extra output.
quantum_inspire_api: Connection to QI platform, required parameter.
backend_type: Backend to use for execution. When no backend_type is provided, the default backend will be
used.
"""
BasicEngine.__init__(self)
self._flushed: bool = False
""" Because engines are meant to be 'single use' by the way ProjectQ is designed,
any additional gates received after a FlushGate triggers an exception. """
self._reset()
self._num_runs: int = num_runs
self._verbose: int = verbose
self._cqasm: str = str()
self._measured_states: Dict[int, float] = {}
self._measured_ids: List[int] = []
self._allocated_qubits: Set[int] = set()
self._max_qubit_id: int = -1
if not quantum_inspire_api:
raise RuntimeError("Api is required")
self.quantum_inspire_api: QuantumInspireAPI = quantum_inspire_api
self.backend_type: Optional[Union[Dict[str, Any], int,
str]] = backend_type
def __init__(self,
process_func=_dummy_process,
qubit_id_mapping_redux=True):
"""
Initialize the OpenQASMEngine object.
Args:
process_func (function): Function to be called periodically to
process a qiskit.QuantumCircuit. This happens anytime a
FlushGate gets processed by the engine.
This function should accept a single argument:
qiskit.QuantumCircuit.
qubit_id_mapping_redux (bool): If True, try to allocate new Qubit
IDs to the next available qreg/creg
(if any), otherwise create a new
qreg/creg.
If False, simply create a new
qreg/creg for each new Qubit ID
Example:
.. code-block:: python
from projectq.cengines import MainEngine, OpenQASMEngine
backend = OpenQASMEngine()
eng = MainEngine(backend=backend)
# do something ...
eng.flush()
qc = backend.circuit # get the corresponding Qiskit circuit
If you have a ProjectQ program with multiple measurements (followed by
`eng.flush()`) the OpenQASMEngine can automatically generate a list of
circuits:
Example:
.. code-block:: python
from projectq.cengines import MainEngine, OpenQASMEngine
qc_list = []
def process(qc):
qc_list.append(qc)
backend = OpenQASMEngine(process_func=process)
eng = MainEngine(backend=backend)
# do something ...
eng.flush()
# do something ...
eng.flush()
qc_list # contains a list of successive circuits
"""
BasicEngine.__init__(self)
self._was_flushed = False
self._openqasm_circuit = QuantumCircuit()
self._process_func = process_func
self._qreg_dict = dict()
self._creg_dict = dict()
self._qubit_id_mapping_redux = qubit_id_mapping_redux
self._reg_index = 0
self._available_indices = []
def __init__(self) -> None:
"""
Initialize the tketBackendEngine.
Initializes local Circuit to an empty Circuit.
"""
BasicEngine.__init__(self)
self._circuit = Circuit()
def __init__(self):
"""
Initialize a UncomputeEngine.
"""
BasicEngine.__init__(self)
# Save all qubit ids from qubits which are created or destroyed.
self._allocated_qubit_ids = set()
self._deallocated_qubit_ids = set()
def __init__(self, total_err_prob=0.01):
BasicEngine.__init__(self)
self._distEngine = DistillationEngine()
self._command_buffer = []
self._Tgate_count = 0
self._logical_qubit_count = 0
self._total_err_prob = total_err_prob
self._remap = dict()
def __init__(self, output="instructions"):
BasicEngine.__init__(self)
self._output = output
self._command_buffer = []
# self._Tgate_count = 0
self._logical_qubit_count = 0
self._remap = dict()
def __init__(self):
"""
Initialize an IBM CNOT Mapper compiler engine.
Resets the mapping.
"""
BasicEngine.__init__(self)
self._reset()
def __init__(self, permutation_rule):
"""
Initialize the Permutation Base Engine.
To use the permutation engine please use a derived class.
"""
BasicEngine.__init__(self)
self._dllist = DoubleLinkedList(
) # dict of lists containing operations for each qubit
self._perm = permutation_rule(self._dllist)
def __init__(self,
num_runs: int = 1024,
verbose: int = 0,
quantum_inspire_api: Optional[QuantumInspireAPI] = None,
backend_type: Optional[Union[int, str]] = None) -> None:
"""
Initialize the Backend object.
:param num_runs: Number of runs to collect statistics (default is 1024).
:param verbose: Verbosity level, defaults to 0, which produces no extra output.
:param quantum_inspire_api: Connection to QI platform, optional parameter.
:param backend_type: Backend to use for execution.
When no backend_type is provided, the default backend will be used.
:raises AuthenticationError: When an authentication error occurs.
"""
BasicEngine.__init__(self)
self._flushed: bool = False
""" Because engines are meant to be 'single use' by the way ProjectQ is designed,
any additional gates received after a FlushGate triggers an exception. """
self._clear: bool = True
self._qasm: str = ""
self._reset()
self._verbose: int = verbose
self._cqasm: str = str()
self._measured_states: Dict[int, float] = {}
self._measured_ids: List[int] = []
self._allocation_map: List[Tuple[int, int]] = []
self._max_qubit_id: int = -1
self._quantum_inspire_result: Dict[str, Any] = {}
if quantum_inspire_api is None:
try:
quantum_inspire_api = QuantumInspireAPI()
except AuthenticationError as ex:
raise AuthenticationError(
'Make sure you have saved your token credentials on disk or '
'provide a QuantumInspireAPI instance as parameter to QIBackend'
) from ex
self._quantum_inspire_api: QuantumInspireAPI = quantum_inspire_api
self._backend_type: Dict[
str,
Any] = self._quantum_inspire_api.get_backend_type(backend_type)
if num_runs < 1 or num_runs > self._backend_type['max_number_of_shots']:
raise ProjectQBackendError(
f'Invalid number of runs (num_runs={num_runs})')
self._num_runs: int = num_runs
self._full_state_projection = not self._backend_type[
"is_hardware_backend"]
self._is_simulation_backend = not self._backend_type[
"is_hardware_backend"]
self._max_number_of_qubits: int = self._backend_type[
"number_of_qubits"]
self._one_qubit_gates: Tuple[Any, ...] = self._get_one_qubit_gates()
self._two_qubit_gates: Tuple[Any, ...] = self._get_two_qubit_gates()
self._three_qubit_gates: Tuple[Any,
...] = self._get_three_qubit_gates()
def __init__(self, qubits):
"""
Initialize the control engine.
Args:
qubits (list of Qubit objects): qubits conditional on which the following
operations are executed.
"""
BasicEngine.__init__(self)
self._qubits = qubits
def __init__(self, p, noise_model=None):
"""
Initialize NoiseEngine object
"""
self.p = p # Delete this later
noise_model = deepcopy(noise_model)
BasicEngine.__init__(self)
self.noise_model = deepcopy(noise_model)
def __init__(self,
decomposition_rule_set,
decomposition_chooser=lambda cmd, decomposition_list:
decomposition_list[0],
merge_rules=()):
BasicEngine.__init__(self)
self._cached_results = dict()
self.decomposition_rule_set = decomposition_rule_set
self.decomposition_chooser = decomposition_chooser
self.merge_rules = merge_rules
def __init__(self):
"""
Initialize a resource counter engine.
Sets all statistics to zero.
"""
BasicEngine.__init__(self)
self.gate_counts = dict()
self._active_qubits = 0
self.max_width = 0
def __init__(self, m=5):
"""
Initialize a LocalOptimizer object.
Args:
m (int): Number of gates to cache per qubit, before sending on the
first gate.
"""
BasicEngine.__init__(self)
self._l = [[]] # list of lists containing operations for each qubit
self._m = m # wait for m gates before sending on
def __init__(self, save_commands=False):
"""
Initialize DummyEngine
Args:
save_commands (default = False): If True, commands are saved in
self.received_commands.
"""
BasicEngine.__init__(self)
self.save_commands = save_commands
self.received_commands = []
def __init__(self, map_fun=lambda x: x):
"""
Initialize the mapper to a given mapping. If no mapping function is
provided, the qubit id is used as the location.
Args:
map_fun (function): Function which, given the qubit id, returns
an integer describing the physical location.
"""
BasicEngine.__init__(self)
self.map = map_fun
def __init__(self, tags=[ComputeTag, UncomputeTag]):
"""
Construct the TagRemover.
Args:
tags: A list of meta tag classes (e.g., [ComputeTag, UncomputeTag])
denoting the tags to remove
"""
BasicEngine.__init__(self)
assert isinstance(tags, list)
self._tags = tags
def __init__(self, connectivity):
"""
Initialize the engine.
Args:
connectivity (set): Set of tuples (c, t) where if (c, t) is an
element of the set means that a CNOT can be performed between
the physical ids (c, t) with c being the control and t being
the target qubit.
"""
BasicEngine.__init__(self)
self.connectivity = connectivity
def __init__(self,
supremacy_circuit=False,
num_splits=10**6,
cluster_size=4):
BasicEngine.__init__(self)
self._cmd_list = []
self._was_scheduling = False
self._init = False
self._supremacy_circuit = supremacy_circuit
self.NUM_SPLITS = num_splits
self.CLUSTER_SIZE = cluster_size
self._deallocations_cache = []
def __init__(self, filterfun):
"""
Initializer: The provided filterfun returns True for all commands
which do not need replacement and False for commands that do.
Args:
filterfun (function): Filter function which returns True for
available commands, and False otherwise. filterfun will be
called as filterfun(self, cmd).
"""
BasicEngine.__init__(self)
self._filterfun = filterfun
def __init__(self):
"""
Initialize a resource counter engine.
Sets all statistics to zero.
"""
BasicEngine.__init__(self)
self.gate_counts = {}
self.gate_class_counts = {}
self._active_qubits = 0
self.max_width = 0
# key: qubit id, depth of this qubit
self._depth_of_qubit = dict()
self._previous_max_depth = 0
def __init__(self,
use_hardware=False,
num_runs=100,
verbose=False,
token='',
device='simulator',
num_retries=3000,
interval=1,
retrieve_execution=None):
"""
Initialize the Backend object.
Args:
use_hardware (bool): If True, the code is run on the AQT quantum
chip (instead of using the AQT simulator)
num_runs (int): Number of runs to collect statistics.
(default is 100, max is usually around 200)
verbose (bool): If True, statistics are printed, in addition to
the measurement result being registered (at the end of the
circuit).
token (str): AQT user API token.
device (str): name of the AQT device to use. simulator By default
num_retries (int): Number of times to retry to obtain
results from the AQT API. (default is 3000)
interval (float, int): Number of seconds between successive
attempts to obtain results from the AQT API.
(default is 1)
retrieve_execution (int): Job ID to retrieve instead of re-
running the circuit (e.g., if previous run timed out).
"""
BasicEngine.__init__(self)
self._reset()
if use_hardware:
self.device = device
else:
self.device = 'simulator'
self._clear = True
self._num_runs = num_runs
self._verbose = verbose
self._token = token
self._num_retries = num_retries
self._interval = interval
self._probabilities = dict()
self._circuit = []
self._mapper = []
self._measured_ids = []
self._allocated_qubits = set()
self._retrieve_execution = retrieve_execution
def __init__(self, accept_input=False, default_measure=0):
"""
Initialize a circuit drawing engine(mpl)
Args:
accept_input (bool): If accept_input is true, the printer queries
the user to input measurement results if the CircuitDrawerMPL
is the last engine. Otherwise, all measurements yield the
result default_measure (0 or 1).
default_measure (bool): Default value to use as measurement
results if accept_input is False and there is no underlying
backend to register real measurement results.
"""
BasicEngine.__init__(self)
self._accept_input = accept_input
self._default_measure = default_measure
self._map = dict()
self._qubit_lines = {}
