def make_immutable(obj):
"""Delete the __setattr__ property to make the object mostly immutable."""
# TODO figure out how to get correct error message
# def throw_immutability_exception(self, *args):
# raise OpflowError('Operator convenience globals are immutable.')
obj.__setattr__ = None
return obj
# 1-Qubit Paulis
X = make_immutable(PauliOp(Pauli("X")))
Y = make_immutable(PauliOp(Pauli("Y")))
Z = make_immutable(PauliOp(Pauli("Z")))
I = make_immutable(PauliOp(Pauli("I")))
# Clifford+T, and some other common non-parameterized gates
CX = make_immutable(CircuitOp(CXGate()))
S = make_immutable(CircuitOp(SGate()))
H = make_immutable(CircuitOp(HGate()))
T = make_immutable(CircuitOp(TGate()))
Swap = make_immutable(CircuitOp(SwapGate()))
CZ = make_immutable(CircuitOp(CZGate()))
# 1-Qubit Paulis
Zero = make_immutable(DictStateFn("0"))
One = make_immutable(DictStateFn("1"))
Plus = make_immutable(H.compose(Zero))
Minus = make_immutable(H.compose(X).compose(Zero))
def sample_circuits(
self,
circuit_sfns: Optional[List[CircuitStateFn]] = None,
param_bindings: Optional[List[Dict[Parameter, float]]] = None,
) -> Dict[int, List[StateFn]]:
r"""
Samples the CircuitStateFns and returns a dict associating their ``id()`` values to their
replacement DictStateFn or VectorStateFn. If param_bindings is provided,
the CircuitStateFns are broken into their parameterizations, and a list of StateFns is
returned in the dict for each circuit ``id()``. Note that param_bindings is provided here
in a different format than in ``convert``, and lists of parameters within the dict is not
supported, and only binding dicts which are valid to be passed into Terra can be included
in this list.
Args:
circuit_sfns: The list of CircuitStateFns to sample.
param_bindings: The parameterizations to bind to each CircuitStateFn.
Returns:
The dictionary mapping ids of the CircuitStateFns to their replacement StateFns.
Raises:
OpflowError: if extracted circuits are empty.
"""
if not circuit_sfns and not self._transpiled_circ_cache:
raise OpflowError("CircuitStateFn is empty and there is no cache.")
if circuit_sfns:
self._transpiled_circ_templates = None
if self._statevector or circuit_sfns[0].from_operator:
circuits = [op_c.to_circuit(meas=False) for op_c in circuit_sfns]
else:
circuits = [op_c.to_circuit(meas=True) for op_c in circuit_sfns]
try:
self._transpiled_circ_cache = self.quantum_instance.transpile(
circuits, pass_manager=self.quantum_instance.unbound_pass_manager
)
except QiskitError:
logger.debug(
r"CircuitSampler failed to transpile circuits with unbound "
r"parameters. Attempting to transpile only when circuits are bound "
r"now, but this can hurt performance due to repeated transpilation."
)
self._transpile_before_bind = False
self._transpiled_circ_cache = circuits
else:
circuit_sfns = list(self._circuit_ops_cache.values())
if param_bindings is not None:
if self._param_qobj:
start_time = time()
ready_circs = self._prepare_parameterized_run_config(param_bindings)
end_time = time()
logger.debug("Parameter conversion %.5f (ms)", (end_time - start_time) * 1000)
else:
start_time = time()
ready_circs = [
circ.assign_parameters(_filter_params(circ, binding))
for circ in self._transpiled_circ_cache
for binding in param_bindings
]
end_time = time()
logger.debug("Parameter binding %.5f (ms)", (end_time - start_time) * 1000)
else:
ready_circs = self._transpiled_circ_cache
# run transpiler passes on bound circuits
if self._transpile_before_bind and self.quantum_instance.bound_pass_manager is not None:
ready_circs = self.quantum_instance.transpile(
ready_circs, pass_manager=self.quantum_instance.bound_pass_manager
)
results = self.quantum_instance.execute(
ready_circs, had_transpiled=self._transpile_before_bind
)
if param_bindings is not None and self._param_qobj:
self._clean_parameterized_run_config()
# Wipe parameterizations, if any
# self.quantum_instance._run_config.parameterizations = None
sampled_statefn_dicts = {}
for i, op_c in enumerate(circuit_sfns):
# Taking square root because we're replacing a statevector
# representation of probabilities.
reps = len(param_bindings) if param_bindings is not None else 1
c_statefns = []
for j in range(reps):
circ_index = (i * reps) + j
circ_results = results.data(circ_index)
if "expval_measurement" in circ_results:
avg = circ_results["expval_measurement"]
# Will be replaced with just avg when eval is called later
num_qubits = circuit_sfns[0].num_qubits
result_sfn = DictStateFn(
"0" * num_qubits,
coeff=avg * op_c.coeff,
is_measurement=op_c.is_measurement,
from_operator=op_c.from_operator,
)
elif self._statevector:
result_sfn = StateFn(
op_c.coeff * results.get_statevector(circ_index),
is_measurement=op_c.is_measurement,
)
else:
shots = self.quantum_instance._run_config.shots
result_sfn = DictStateFn(
{
b: (v / shots) ** 0.5 * op_c.coeff
for (b, v) in results.get_counts(circ_index).items()
},
is_measurement=op_c.is_measurement,
from_operator=op_c.from_operator,
)
if self._attach_results:
result_sfn.execution_results = circ_results
c_statefns.append(result_sfn)
sampled_statefn_dicts[id(op_c)] = c_statefns
return sampled_statefn_dicts
def make_immutable(obj):
""" Delete the __setattr__ property to make the object mostly immutable. """
# TODO figure out how to get correct error message
# def throw_immutability_exception(self, *args):
# raise OpflowError('Operator convenience globals are immutable.')
obj.__setattr__ = None
return obj
# 1-Qubit Paulis
X = make_immutable(PauliOp(Pauli('X')))
Y = make_immutable(PauliOp(Pauli('Y')))
Z = make_immutable(PauliOp(Pauli('Z')))
I = make_immutable(PauliOp(Pauli('I')))
# Clifford+T, and some other common non-parameterized gates
CX = make_immutable(CircuitOp(CXGate()))
S = make_immutable(CircuitOp(SGate()))
H = make_immutable(CircuitOp(HGate()))
T = make_immutable(CircuitOp(TGate()))
Swap = make_immutable(CircuitOp(SwapGate()))
CZ = make_immutable(CircuitOp(CZGate()))
# 1-Qubit Paulis
Zero = make_immutable(DictStateFn('0'))
One = make_immutable(DictStateFn('1'))
Plus = make_immutable(H.compose(Zero))
Minus = make_immutable(H.compose(X).compose(Zero))