def __init__(self,
configuration=None,
properties=None,
provider=None,
**backend_options):
self._controller = aer_controller_execute()
# Update available methods and devices for class
if AerSimulator._AVAILABLE_METHODS is None:
AerSimulator._AVAILABLE_METHODS = available_methods(
self._controller, AerSimulator._SIMULATION_METHODS)
if AerSimulator._AVAILABLE_DEVICES is None:
AerSimulator._AVAILABLE_DEVICES = available_devices(
self._controller, AerSimulator._SIMULATION_DEVICES)
# Default configuration
if configuration is None:
configuration = QasmBackendConfiguration.from_dict(
AerSimulator._DEFAULT_CONFIGURATION)
super().__init__(configuration,
properties=properties,
available_methods=AerSimulator._AVAILABLE_METHODS,
provider=provider,
backend_options=backend_options)
def __init__(self, configuration=None, provider=None, **fields):
super().__init__(
configuration=(configuration or QasmBackendConfiguration.from_dict(
self.DEFAULT_CONFIGURATION)),
provider=provider,
**fields,
)
def __init__(self,
configuration=None,
properties=None,
provider=None,
**backend_options):
warn(
'The `StatevectorSimulator` backend will be deprecated in the'
' future. It has been superseded by the `AerSimulator`'
' backend. To obtain legacy functionality initalize with'
' `AerSimulator(method="statevector")` and append run circuits'
' with the `save_state` instruction.', PendingDeprecationWarning)
self._controller = statevector_controller_execute()
if StatevectorSimulator._AVAILABLE_METHODS is None:
StatevectorSimulator._AVAILABLE_METHODS = available_methods(
self._controller, [
'automatic', 'statevector', 'statevector_gpu',
'statevector_thrust'
])
if configuration is None:
configuration = QasmBackendConfiguration.from_dict(
StatevectorSimulator._DEFAULT_CONFIGURATION)
else:
configuration.open_pulse = False
super().__init__(
configuration,
properties=properties,
available_methods=StatevectorSimulator._AVAILABLE_METHODS,
provider=provider,
backend_options=backend_options)
def _discover_remote_backends(self):
"""Return the remote backends available.
Returns:
dict[str:IBMQBackend]: a dict of the remote backend instances,
keyed by backend name.
"""
ret = OrderedDict()
configs_list = self._api.available_backends()
for raw_config in configs_list:
try:
if raw_config.get('open_pulse', False):
config = PulseBackendConfiguration.from_dict(raw_config)
else:
config = QasmBackendConfiguration.from_dict(raw_config)
backend_cls = IBMQSimulator if config.simulator else IBMQBackend
ret[config.backend_name] = backend_cls(
configuration=config,
provider=self._ibm_provider,
credentials=self.credentials,
api=self._api)
except ModelValidationError as ex:
logger.warning(
'Remote backend "%s" could not be instantiated due to an '
'invalid config: %s',
raw_config.get('backend_name',
raw_config.get('name', 'unknown')),
ex)
return ret
def __init__(self, backend, backend_name, local=True):
"""FakeBackend initializer.
Args:
backend (IBMQBackend): IBMQBackend instance
backend_name (str): The name to give the backend.
local (bool): Determines if Aer of IBMQ simulator should be used.
"""
if backend.configuration().open_pulse:
config = PulseBackendConfiguration.from_dict(backend.configuration().to_dict())
else:
config = QasmBackendConfiguration.from_dict(backend.configuration().to_dict())
super().__init__(config)
self._credentials = _Credentials()
self._properties = backend.properties()
self._configuration.simulator = True
self._configuration.local = local
self._configuration.backend_name = backend_name
if AER_VERSION >= 60000:
self.noise_model = NoiseModel.from_backend(self, warnings=False)
else:
self.noise_model = NoiseModel.from_backend(self)
if local:
self.sim = Aer.get_backend('qasm_simulator')
else:
pro = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
self.sim = pro.backends.ibmq_qasm_simulator
def __init__(self,
configuration=None,
properties=None,
provider=None,
**backend_options):
self._controller = aer_controller_execute()
# Update available methods and devices for class
if AerSimulator._AVAILABLE_METHODS is None:
AerSimulator._AVAILABLE_METHODS = available_methods(
self._controller, AerSimulator._SIMULATION_METHODS)
if AerSimulator._AVAILABLE_DEVICES is None:
AerSimulator._AVAILABLE_DEVICES = available_devices(
self._controller, AerSimulator._SIMULATION_DEVICES)
# Default configuration
if configuration is None:
configuration = QasmBackendConfiguration.from_dict(
AerSimulator._DEFAULT_CONFIGURATION)
# Cache basis gates since computing the intersection
# of noise model, method, and config gates is expensive.
self._cached_basis_gates = self._BASIS_GATES['automatic']
super().__init__(configuration,
properties=properties,
provider=provider,
backend_options=backend_options)
def __init__(self, configuration=None, provider=None):
super().__init__(configuration=(configuration
or QasmBackendConfiguration.from_dict(
self.DEFAULT_CONFIGURATION)),
provider=provider)
# Define attributes in __init__.
self._local_random = np.random.RandomState()
self._classical_memory = 0
self._classical_register = 0
self._statevector = 0
self._number_of_cmembits = 0
self._number_of_qubits = 0
self._shots = 0
self._memory = False
self._initial_statevector = self.DEFAULT_OPTIONS["initial_statevector"]
self._chop_threshold = self.DEFAULT_OPTIONS["chop_threshold"]
self._qobj_config = None
# TEMP
self._sample_measure = False
if self.SPLIT_STATES:
# _substates field will contain 2 statevectors corresponding to
# measurement results 0 and 1
self._substates = []
self._substate_probabilities = []
def __init__(self,
configuration=None,
properties=None,
provider=None,
**backend_options):
warn('The `UnitarySimulator` backend will be deprecated in the'
' future. It has been superseded by the `AerSimulator`'
' backend. To obtain legacy functionality initialize with'
' `AerSimulator(method="unitary")` and append run circuits'
' with the `save_state` instruction.', PendingDeprecationWarning)
self._controller = aer_controller_execute()
if UnitarySimulator._AVAILABLE_DEVICES is None:
UnitarySimulator._AVAILABLE_DEVICES = available_devices(
self._controller, UnitarySimulator._SIMULATION_DEVICES)
if configuration is None:
configuration = QasmBackendConfiguration.from_dict(
UnitarySimulator._DEFAULT_CONFIGURATION)
else:
configuration.open_pulse = False
super().__init__(configuration,
properties=properties,
provider=provider,
backend_options=backend_options)
def __init__(self,
configuration=None,
properties=None,
provider=None,
**backend_options):
warn(
'The `QasmSimulator` backend will be deprecated in the'
' future. It has been superseded by the `AerSimulator`'
' backend.', PendingDeprecationWarning)
self._controller = qasm_controller_execute()
# Update available methods for class
if QasmSimulator._AVAILABLE_METHODS is None:
QasmSimulator._AVAILABLE_METHODS = available_methods(
self._controller, QasmSimulator._SIMULATION_METHODS)
# Default configuration
if configuration is None:
configuration = QasmBackendConfiguration.from_dict(
QasmSimulator._DEFAULT_CONFIGURATION)
else:
configuration.open_pulse = False
super().__init__(configuration,
properties=properties,
available_methods=QasmSimulator._AVAILABLE_METHODS,
provider=provider,
backend_options=backend_options)
def configuration_from_server_data(
raw_config: Dict,
instance: str = "",
) -> Optional[Union[QasmBackendConfiguration, PulseBackendConfiguration]]:
"""Create an IBMBackend instance from raw server data.
Args:
raw_config: Raw configuration.
instance: Service instance.
Returns:
Backend configuration.
"""
# Make sure the raw_config is of proper type
if not isinstance(raw_config, dict):
logger.warning( # type: ignore[unreachable]
"An error occurred when retrieving backend "
"information. Some backends might not be available.")
return None
try:
_decode_backend_configuration(raw_config)
try:
return PulseBackendConfiguration.from_dict(raw_config)
except (KeyError, TypeError):
return QasmBackendConfiguration.from_dict(raw_config)
except Exception: # pylint: disable=broad-except
logger.warning(
'Remote backend "%s" for service instance %s could not be instantiated due to an '
"invalid config: %s",
raw_config.get("backend_name", raw_config.get("name", "unknown")),
repr(instance),
traceback.format_exc(),
)
return None
def __init__(self,
configuration=None,
properties=None,
provider=None,
**backend_options):
warn(
'The `QasmSimulator` backend will be deprecated in the'
' future. It has been superseded by the `AerSimulator`'
' backend.', PendingDeprecationWarning)
self._controller = aer_controller_execute()
# Update available methods for class
if QasmSimulator._AVAILABLE_METHODS is None:
QasmSimulator._AVAILABLE_METHODS = available_methods(
self._controller, QasmSimulator._SIMULATION_METHODS)
# Default configuration
if configuration is None:
configuration = QasmBackendConfiguration.from_dict(
QasmSimulator._DEFAULT_CONFIGURATION)
else:
configuration.open_pulse = False
# Cache basis gates since computing the intersection
# of noise model, method, and config gates is expensive.
self._cached_basis_gates = self._DEFAULT_BASIS_GATES
super().__init__(configuration,
properties=properties,
provider=provider,
backend_options=backend_options)
def __init__(self, configuration=None, provider=None):
super().__init__(
controller=bdd_controller,
configuration=QasmBackendConfiguration.from_dict(
self.DEFAULT_CONFIGURATION),
provider=provider,
)
def __init__(self):
dirname = os.path.dirname(__file__)
filename = "conf_rochester.json"
with open(os.path.join(dirname, filename), "r") as f_conf:
conf = json.load(f_conf)
configuration = QasmBackendConfiguration.from_dict(conf)
configuration.backend_name = 'fake_rochester'
super().__init__(configuration)
def __init__(self, configuration=None, provider=None):
super().__init__(configuration=(
configuration or QasmBackendConfiguration.from_dict(self.DEFAULT_CONFIGURATION)),
provider=provider)
# Define attributes inside __init__.
self._unitary = None
self._number_of_qubits = 0
self._initial_unitary = None
self._chop_threshold = 1e-15
def __init__(self):
dirname = os.path.dirname(__file__)
filename = "conf_santiago.json"
with open(os.path.join(dirname, filename)) as f_conf:
conf = json.load(f_conf)
configuration = QasmBackendConfiguration.from_dict(conf)
configuration.backend_name = 'fake_santiago'
self._defaults = None
self._properties = None
super().__init__(configuration)
def _method_configuration(method=None):
"""Return QasmBackendConfiguration."""
# Default configuration
config = QasmBackendConfiguration.from_dict(
QasmSimulator._DEFAULT_CONFIGURATION)
# Statevector methods
if method in ['statevector', 'statevector_gpu', 'statevector_thrust']:
config.description = 'A C++ QasmQobj statevector simulator with noise'
# Density Matrix methods
elif method in [
'density_matrix', 'density_matrix_gpu', 'density_matrix_thrust'
]:
config.n_qubits = config.n_qubits // 2
config.description = 'A C++ QasmQobj density matrix simulator with noise'
config.basis_gates = [
'u1', 'u2', 'u3', 'u', 'p', 'r', 'rx', 'ry', 'rz', 'id', 'x',
'y', 'z', 'h', 's', 'sdg', 'sx', 't', 'tdg', 'swap', 'cx',
'cy', 'cz', 'cp', 'cu1', 'rxx', 'ryy', 'rzz', 'rzx', 'ccx',
'unitary', 'diagonal', 'kraus', 'superop'
'roerror', 'delay', 'pauli'
]
# Matrix product state method
elif method == 'matrix_product_state':
config.description = 'A C++ QasmQobj matrix product state simulator with noise'
config.basis_gates = [
'u1', 'u2', 'u3', 'u', 'p', 'cp', 'cx', 'cz', 'id', 'x', 'y',
'z', 'h', 's', 'sdg', 'sx', 't', 'tdg', 'swap', 'ccx',
'unitary', 'roerror', 'delay', 'r', 'rx', 'ry', 'rz', 'rxx',
'ryy', 'rzz', 'rzx'
]
# Stabilizer method
elif method == 'stabilizer':
config.n_qubits = 5000 # TODO: estimate from memory
config.description = 'A C++ QasmQobj Clifford stabilizer simulator with noise'
config.basis_gates = [
'id', 'x', 'y', 'z', 'h', 's', 'sdg', 'sx', 'cx', 'cy', 'cz',
'swap', 'roerror', 'delay'
]
# Extended stabilizer method
elif method == 'extended_stabilizer':
config.n_qubits = 63 # TODO: estimate from memory
config.description = 'A C++ QasmQobj ranked stabilizer simulator with noise'
config.basis_gates = [
'cx', 'cz', 'id', 'x', 'y', 'z', 'h', 's', 'sdg', 'sx', 'swap',
'u0', 'u1', 'p', 'ccx', 'ccz', 'roerror', 'delay'
]
return config
def __init__(self):
"""
0 ↔ 1 ↔ 3 ↔ 4
↕
2
"""
dirname = os.path.dirname(__file__)
filename = "conf_ourense.json"
with open(os.path.join(dirname, filename)) as f_conf:
conf = json.load(f_conf)
configuration = QasmBackendConfiguration.from_dict(conf)
configuration.backend_name = 'fake_ourense'
super().__init__(configuration)
def __init__(self, configuration=None, provider=None, **fields):
super().__init__(configuration=(configuration
or QasmBackendConfiguration.from_dict(
self.DEFAULT_CONFIGURATION)),
provider=provider,
**fields)
# Define attributes inside __init__.
self._unitary = None
self._number_of_qubits = 0
self._initial_unitary = None
self._global_phase = 0
self._chop_threshold = self.options.get('chop_threshold')
def __init__(self):
"""
1
/ |
0 - 2 - 3
| /
4
"""
dirname = os.path.dirname(__file__)
filename = "conf_yorktown.json"
with open(os.path.join(dirname, filename), "r") as f_conf:
conf = json.load(f_conf)
configuration = QasmBackendConfiguration.from_dict(conf)
configuration.backend_name = 'fake_yorktown'
super().__init__(configuration)
def __init__(self):
"""
0 ↔ 1 ↔ 2
↕
3
↕
4
"""
dirname = os.path.dirname(__file__)
filename = "conf_essex.json"
with open(os.path.join(dirname, filename), "r") as f_conf:
conf = json.load(f_conf)
configuration = QasmBackendConfiguration.from_dict(conf)
configuration.backend_name = 'fake_essex'
self._defaults = None
self._properties = None
super().__init__(configuration)
def _discover_remote_backends(self,
timeout: Optional[float] = None
) -> Dict[str, IBMQBackend]:
"""Return the remote backends available for this provider.
Args:
timeout: Maximum number of seconds to wait for the discovery of
remote backends.
Returns:
A dict of the remote backend instances, keyed by backend name.
"""
ret = OrderedDict() # type: ignore[var-annotated]
configs_list = self._api_client.list_backends(timeout=timeout)
for raw_config in configs_list:
# Make sure the raw_config is of proper type
if not isinstance(raw_config, dict):
logger.warning(
"An error occurred when retrieving backend "
"information. Some backends might not be available.")
continue
try:
decode_backend_configuration(raw_config)
if raw_config.get('open_pulse', False):
config = PulseBackendConfiguration.from_dict(raw_config)
else:
config = QasmBackendConfiguration.from_dict(raw_config)
backend_cls = IBMQSimulator if config.simulator else IBMQBackend
ret[config.backend_name] = backend_cls(
configuration=config,
provider=self,
credentials=self.credentials,
api_client=self._api_client)
except Exception as ex: # pylint: disable=broad-except
logger.warning(
'Remote backend "%s" for provider %s could not be instantiated due to an '
'invalid config: %s: %s',
raw_config.get('backend_name',
raw_config.get('name', 'unknown')),
repr(self),
type(ex).__name__, ex)
return ret
def __init__(self, configuration=None, provider=None, **fields):
super().__init__(configuration=(configuration
or QasmBackendConfiguration.from_dict(
self._configuration)),
provider=provider,
**fields)
# Define attributes in __init__.
self._local_random = np.random.RandomState()
self._classical_memory = 0
self._classical_register = 0
self._statevector = 0
self._number_of_cmembits = 0
self._number_of_qubits = 0
self._shots = 0
self._memory = False
self._initial_statevector = self.options.get("initial_statevector")
self._qobj_config = None
# TEMP
self._sample_measure = False
def __init__(self, configuration=None, provider=None):
super().__init__(configuration=(
configuration or QasmBackendConfiguration.from_dict(self.DEFAULT_CONFIGURATION)),
provider=provider)
# Define attributes in __init__.
self._local_random = np.random.RandomState()
self._classical_memory = 0
self._classical_register = 0
self._statevector = 0
self._number_of_cmembits = 0
self._number_of_qubits = 0
self._shots = 0
self._memory = False
self._initial_statevector = self.DEFAULT_OPTIONS["initial_statevector"]
self._chop_threshold = self.DEFAULT_OPTIONS["chop_threshold"]
self._qobj_config = None
# TEMP
self._sample_measure = False
def _discover_remote_backends(self,
timeout: Optional[float] = None
) -> Dict[str, IBMQBackend]:
"""Return the remote backends available.
Args:
timeout (float or None): number of seconds to wait for the discovery.
Returns:
dict[str:IBMQBackend]: a dict of the remote backend instances,
keyed by backend name.
"""
ret = OrderedDict()
configs_list = self._api.list_backends(timeout=timeout)
for raw_config in configs_list:
# Make sure the raw_config is of proper type
if not isinstance(raw_config, dict):
logger.warning(
"An error occurred when retrieving backend "
"information. Some backends might not be available.")
continue
try:
if raw_config.get('open_pulse', False):
config = PulseBackendConfiguration.from_dict(raw_config)
else:
config = QasmBackendConfiguration.from_dict(raw_config)
backend_cls = IBMQSimulator if config.simulator else IBMQBackend
ret[config.backend_name] = backend_cls(
configuration=config,
provider=self,
credentials=self.credentials,
api=self._api)
except ModelValidationError as ex:
logger.warning(
'Remote backend "%s" could not be instantiated due to an '
'invalid config: %s',
raw_config.get('backend_name',
raw_config.get('name', 'unknown')), ex)
return ret
def __init__(self):
"""
00 ↔ 01 ↔ 02 ↔ 03 ↔ 04
↕ ↕
05 06
↕ ↕
07 ↔ 08 ↔ 09 ↔ 10 ↔ 11 ↔ 12 ↔ 13 ↔ 14 ↔ 15
↕ ↕ ↕
16 17 18
↕ ↕ ↕
19 ↔ 20 ↔ 21 ↔ 22 ↔ 23 ↔ 24 ↔ 25 ↔ 26 ↔ 27
"""
dirname = os.path.dirname(__file__)
filename = "conf_cambridge.json"
with open(os.path.join(dirname, filename), "r") as f_conf:
conf = json.load(f_conf)
configuration = QasmBackendConfiguration.from_dict(conf)
configuration.backend_name = 'fake_cambridge'
self._defaults = None
self._properties = None
super().__init__(configuration)
def __init__(self,
configuration=None,
properties=None,
provider=None,
**backend_options):
self._controller = unitary_controller_execute()
if UnitarySimulator._AVAILABLE_METHODS is None:
UnitarySimulator._AVAILABLE_METHODS = available_methods(
self._controller,
['automatic', 'unitary', 'unitary_gpu', 'unitary_thrust'])
if configuration is None:
configuration = QasmBackendConfiguration.from_dict(
UnitarySimulator._DEFAULT_CONFIGURATION)
super().__init__(configuration,
properties=properties,
available_methods=UnitarySimulator._AVAILABLE_METHODS,
provider=provider,
backend_options=backend_options)
def __init__(self, configuration=None, provider=None):
super().__init__(statevector_controller_execute,
QasmBackendConfiguration.from_dict(
self.DEFAULT_CONFIGURATION),
provider=provider)
def __init__(self, little_endian=False):
super().__init__(
QasmBackendConfiguration.from_dict(self.CONFIGURATION), None)
self.little_endian = little_endian
def _get_config_from_dict(self, conf):
return QasmBackendConfiguration.from_dict(conf)
