def __init__(self):
BasicEngine.__init__(self)
self._state = 0
self._bit_positions = {}
def __init__(self, backend=None, engine_list=None, verbose=False):
"""
Initialize the main compiler engine and all compiler engines.
Sets 'next_engine'- and 'main_engine'-attributes of all compiler
engines and adds the back-end as the last engine.
Args:
backend (BasicEngine): Backend to send the compiled circuit to.
engine_list (list<BasicEngine>): List of engines / backends to use
as compiler engines. Note: The engine list must not contain
multiple mappers (instances of BasicMapperEngine).
Default: projectq.setups.default.get_engine_list()
verbose (bool): Either print full or compact error messages.
Default: False (i.e. compact error messages).
Example:
.. code-block:: python
from projectq import MainEngine
eng = MainEngine() # uses default engine_list and the Simulator
Instead of the default `engine_list` one can use, e.g., one of the IBM
setups which defines a custom `engine_list` useful for one of the IBM
chips
Example:
.. code-block:: python
import projectq.setups.ibm as ibm_setup
from projectq import MainEngine
eng = MainEngine(engine_list=ibm_setup.get_engine_list())
# eng uses the default Simulator backend
Alternatively, one can specify all compiler engines explicitly, e.g.,
Example:
.. code-block:: python
from projectq.cengines import (TagRemover, AutoReplacer,
LocalOptimizer,
DecompositionRuleSet)
from projectq.backends import Simulator
from projectq import MainEngine
rule_set = DecompositionRuleSet()
engines = [AutoReplacer(rule_set), TagRemover(),
LocalOptimizer(3)]
eng = MainEngine(Simulator(), engines)
"""
BasicEngine.__init__(self)
if backend is None:
backend = Simulator()
else: # Test that backend is BasicEngine object
if not isinstance(backend, BasicEngine):
raise UnsupportedEngineError(
"\nYou supplied a backend which is not supported,\n"
"i.e. not an instance of BasicEngine.\n"
"Did you forget the brackets to create an instance?\n"
"E.g. MainEngine(backend=Simulator) instead of \n"
" MainEngine(backend=Simulator())")
# default engine_list is projectq.setups.default.get_engine_list()
if engine_list is None:
import projectq.setups.default
engine_list = projectq.setups.default.get_engine_list()
self.mapper = None
if isinstance(engine_list, list):
# Test that engine list elements are all BasicEngine objects
for current_eng in engine_list:
if not isinstance(current_eng, BasicEngine):
raise UnsupportedEngineError(
"\nYou supplied an unsupported engine in engine_list,"
"\ni.e. not an instance of BasicEngine.\n"
"Did you forget the brackets to create an instance?\n"
"E.g. MainEngine(engine_list=[AutoReplacer]) instead "
"of\n MainEngine(engine_list=[AutoReplacer()])")
if isinstance(current_eng, BasicMapperEngine):
if self.mapper is None:
self.mapper = current_eng
else:
raise UnsupportedEngineError(
"More than one mapper engine is not supported.")
else:
raise UnsupportedEngineError(
"The provided list of engines is not a list!")
engine_list = engine_list + [backend]
self.backend = backend
# Test that user did not supply twice the same engine instance
num_different_engines = len(set([id(item) for item in engine_list]))
if len(engine_list) != num_different_engines:
raise UnsupportedEngineError(
"\nError:\n You supplied twice the same engine as backend"
" or item in engine_list. This doesn't work. Create two \n"
" separate instances of a compiler engine if it is needed\n"
" twice.\n")
self._qubit_idx = int(0)
for i in range(len(engine_list) - 1):
engine_list[i].next_engine = engine_list[i + 1]
engine_list[i].main_engine = self
engine_list[-1].main_engine = self
engine_list[-1].is_last_engine = True
self.next_engine = engine_list[0]
self.main_engine = self
self.active_qubits = weakref.WeakSet()
self._measurements = dict()
self.dirty_qubits = set()
self.verbose = verbose
# In order to terminate an example code without eng.flush
def atexit_function(weakref_main_eng):
eng = weakref_main_eng()
if eng is not None:
if not hasattr(sys, "last_type"):
eng.flush(deallocate_qubits=True)
# An exception causes the termination, don't send a flush and
# make sure no qubits send deallocation gates anymore as this
# might trigger additional exceptions
else:
for qubit in eng.active_qubits:
qubit.id = -1
self._delfun = atexit_function
weakref_self = weakref.ref(self)
atexit.register(self._delfun, weakref_self)
def __init__(self,
allow_classical_instructions=True,
allow_all=False,
allow_arithmetic=False,
allow_toffoli=False,
allow_nots_with_many_controls=False,
allow_single_qubit_gates=False,
allow_single_qubit_gates_with_controls=False,
allow_classes=(),
allow_custom_predicate=lambda cmd: False,
ban_classes=(),
ban_custom_predicate=lambda cmd: False):
"""
Constructs a LimitedCapabilityEngine that accepts commands based on
the given criteria arguments.
Note that a command is accepted if it meets *none* of the ban criteria
and *any* of the allow criteria.
Args:
allow_classical_instructions (bool):
Enabled by default. Marks classical instruction commands like
'Allocate', 'Flush', etc as available.
allow_all (bool):
Defaults to allowing all commands.
Any ban criteria will override this default.
allow_arithmetic (bool):
Allows gates with the BasicMathGate type.
allow_toffoli (bool):
Allows NOT gates with at most 2 controls.
allow_nots_with_many_controls (bool):
Allows NOT gates with arbitrarily many controls.
allow_single_qubit_gates (bool):
Allows gates that affect only a single qubit
(counting controls).
allow_single_qubit_gates_with_controls (bool):
Allows gates that target only a single qubit.
allow_classes (list[type]):
Allows any gates matching the given class.
allow_custom_predicate (function(Command) : bool):
Allows any gates that cause the given function to return True.
ban_classes (list[type]):
Bans any gates matching the given class.
ban_custom_predicate (function(Command) : bool):
Bans gates that cause the given function to return True.
"""
BasicEngine.__init__(self)
self.allow_arithmetic = allow_arithmetic
self.allow_all = allow_all
self.allow_nots_with_many_controls = allow_nots_with_many_controls
self.allow_single_qubit_gates = allow_single_qubit_gates
self.allow_single_qubit_gates_with_controls = (
allow_single_qubit_gates_with_controls)
self.allow_toffoli = allow_toffoli
self.allow_classical_instructions = allow_classical_instructions
self.allowed_classes = tuple(allow_classes)
self.allow_custom_predicate = allow_custom_predicate
self.ban_classes = tuple(ban_classes)
self.ban_custom_predicate = ban_custom_predicate
def __init__(self):
BasicEngine.__init__(self)
self._commands = []
self._allocated_qubit_ids = set()
self._deallocated_qubit_ids = set()
def __init__(self, backend=None, engine_list=None):
"""
Initialize the main compiler engine and all compiler engines.
Sets 'next_engine'- and 'main_engine'-attributes of all compiler
engines and adds the back-end as the last engine.
Args:
backend (BasicEngine): Backend to send the circuit to.
engine_list (list<BasicEngine>): List of engines / backends to use
as compiler engines.
Example:
.. code-block:: python
from projectq import MainEngine
eng = MainEngine() # uses default setup and the Simulator
Alternatively, one can specify all compiler engines explicitly, e.g.,
Example:
.. code-block:: python
from projectq.cengines import TagRemover,AutoReplacer,LocalOptimizer,DecompositionRuleSet
from projectq.backends import Simulator
from projectq import MainEngine
rule_set = DecompositionRuleSet()
engines = [AutoReplacer(rule_set), TagRemover(), LocalOptimizer(3)]
eng = MainEngine(Simulator(), engines)
"""
BasicEngine.__init__(self)
if backend is None:
backend = Simulator()
else: # Test that backend is BasicEngine object
if not isinstance(backend, BasicEngine):
raise UnsupportedEngineError(
"\nYou supplied a backend which is not supported,\n"
"i.e. not an instance of BasicEngine.\n"
"Did you forget the brackets to create an instance?\n"
"E.g. MainEngine(backend=Simulator) instead of \n"
" MainEngine(backend=Simulator())")
if engine_list is None:
try:
engine_list = projectq.default_engines()
except AttributeError:
from projectq.setups.default import default_engines
engine_list = default_engines()
else: # Test that engine list elements are all BasicEngine objects
if not isinstance(engine_list, list):
raise UnsupportedEngineError(
"\n The engine_list argument is not a list!\n")
for current_eng in engine_list:
if not isinstance(current_eng, BasicEngine):
raise UnsupportedEngineError(
"\nYou supplied an unsupported engine in engine_list,"
"\ni.e. not an instance of BasicEngine.\n"
"Did you forget the brackets to create an instance?\n"
"E.g. MainEngine(engine_list=[AutoReplacer]) instead "
"of\n MainEngine(engine_list=[AutoReplacer()])")
engine_list = engine_list + [backend]
self.backend = backend
# Test that user did not supply twice the same engine instance
num_different_engines = len(set([id(item) for item in engine_list]))
if len(engine_list) != num_different_engines:
raise UnsupportedEngineError(
"\n Error:\n You supplied twice the same engine as backend" +
" or item in engine_list. This doesn't work. Create two \n" +
" separate instances of a compiler engine if it is needed\n" +
" twice.\n")
self._qubit_idx = int(0)
for i in range(len(engine_list) - 1):
engine_list[i].next_engine = engine_list[i + 1]
engine_list[i].main_engine = self
engine_list[-1].main_engine = self
engine_list[-1].is_last_engine = True
self.next_engine = engine_list[0]
self.main_engine = self
self.active_qubits = weakref.WeakSet()
self._measurements = dict()
self.dirty_qubits = set()
# In order to terminate an example code without eng.flush or Measure
self._delfun = lambda x: x.flush(deallocate_qubits=True)
atexit.register(self._delfun, self)
def __init__(self):
BasicEngine.__init__(self)
self._current_mapping = None
def __init__(self) -> None:
BasicEngine.__init__(self)
self._circuit = Circuit()
self._qubit_dictionary: dict = dict()
def __init__(self, rules):
BasicEngine.__init__(self)
self.rules = tuple(rules) + (InverseControlMergeRule(), )
self._last_command = None
def __init__(self):
BasicEngine.__init__(self)
self._circuit = Circuit()
self._qubit_dictionary = dict()
def __init__(self):
BasicEngine.__init__(self)
self.current_mapping = dict()
def __init__(self):
BasicEngine.__init__(self)
self._l = [[]]
def __init__(self): BasicEngine.__init__(self) self.commands = []
def __init__(self):
BasicEngine.__init__(self)
self._states = np.array([0], np.int32)
def __init__(self, *args, **kwargs):
BasicEngine.__init__(self, *args, **kwargs)
self._reset()
