def _run(self, circuit: circuits.Circuit,
param_resolver: study.ParamResolver,
repetitions: int) -> Dict[str, np.ndarray]:
"""See definition in `cirq.SimulatesSamples`."""
if self._ignore_measurement_results:
raise ValueError(
"run() is not supported when ignore_measurement_results = True"
)
param_resolver = param_resolver or study.ParamResolver({})
resolved_circuit = protocols.resolve_parameters(
circuit, param_resolver)
check_all_resolved(resolved_circuit)
qubits = tuple(sorted(resolved_circuit.all_qubits()))
act_on_args = self._create_act_on_args(0, qubits)
prefix, general_suffix = split_into_matching_protocol_then_general(
resolved_circuit, lambda op: not protocols.is_measurement(op))
step_result = None
for step_result in self._core_iterator(
circuit=prefix,
sim_state=act_on_args,
):
pass
assert step_result is not None
if general_suffix.are_all_measurements_terminal() and not any(
general_suffix.findall_operations(
lambda op: isinstance(op, circuits.CircuitOperation))):
return self._run_sweep_sample(general_suffix, repetitions,
act_on_args)
return self._run_sweep_repeat(general_suffix, repetitions, act_on_args)
def _run(
self, circuit: circuits.Circuit, param_resolver: study.ParamResolver, repetitions: int
) -> Dict[str, List[np.ndarray]]:
param_resolver = param_resolver or study.ParamResolver({})
resolved_circuit = protocols.resolve_parameters(circuit, param_resolver)
check_all_resolved(resolved_circuit)
measurements = {} # type: Dict[str, List[np.ndarray]]
if repetitions == 0:
for _, op, _ in resolved_circuit.findall_operations_with_gate_type(ops.MeasurementGate):
measurements[protocols.measurement_key(op)] = np.empty([0, 1])
for _ in range(repetitions):
all_step_results = self._base_iterator(
resolved_circuit, qubit_order=ops.QubitOrder.DEFAULT, initial_state=0
)
for step_result in all_step_results:
for k, v in step_result.measurements.items():
if not k in measurements:
measurements[k] = []
measurements[k].append(np.array(v, dtype=bool))
return {k: np.array(v) for k, v in measurements.items()}
def _run(self, circuit: circuits.Circuit,
param_resolver: study.ParamResolver,
repetitions: int) -> Dict[str, np.ndarray]:
"""See definition in `cirq.SimulatesSamples`."""
param_resolver = param_resolver or study.ParamResolver({})
resolved_circuit = protocols.resolve_parameters(
circuit, param_resolver)
check_all_resolved(resolved_circuit)
qubit_order = sorted(resolved_circuit.all_qubits())
prefix, general_suffix = split_into_matching_protocol_then_general(
resolved_circuit, lambda op: not protocols.is_measurement(op))
step_result = None
for step_result in self._base_iterator(
circuit=prefix,
qubit_order=qubit_order,
initial_state=0,
):
pass
assert step_result is not None
intermediate_state = step_result._density_matrix
if general_suffix.are_all_measurements_terminal() and not any(
general_suffix.findall_operations(
lambda op: isinstance(op, circuits.CircuitOperation))):
return self._run_sweep_sample(general_suffix, repetitions,
qubit_order, intermediate_state)
return self._run_sweep_repeat(general_suffix, repetitions, qubit_order,
intermediate_state)
def _run(
self,
circuit: circuits.AbstractCircuit,
param_resolver: study.ParamResolver,
repetitions: int,
) -> Dict[str, np.ndarray]:
"""See definition in `cirq.SimulatesSamples`."""
if self._ignore_measurement_results:
raise ValueError(
"run() is not supported when ignore_measurement_results = True"
)
param_resolver = param_resolver or study.ParamResolver({})
resolved_circuit = protocols.resolve_parameters(
circuit, param_resolver)
check_all_resolved(resolved_circuit)
qubits = tuple(sorted(resolved_circuit.all_qubits()))
act_on_args = self._create_act_on_args(0, qubits)
prefix, general_suffix = (split_into_matching_protocol_then_general(
resolved_circuit, self._can_be_in_run_prefix) if
self._can_be_in_run_prefix(self.noise) else
(resolved_circuit[0:0], resolved_circuit))
step_result = None
for step_result in self._core_iterator(
circuit=prefix,
sim_state=act_on_args,
):
pass
general_ops = list(general_suffix.all_operations())
if all(isinstance(op.gate, ops.MeasurementGate) for op in general_ops):
for step_result in self._core_iterator(
circuit=general_suffix,
sim_state=act_on_args,
all_measurements_are_terminal=True,
):
pass
assert step_result is not None
measurement_ops = [
cast(ops.GateOperation, op) for op in general_ops
]
return step_result.sample_measurement_ops(measurement_ops,
repetitions,
seed=self._prng)
measurements: Dict[str, List[np.ndarray]] = {}
for i in range(repetitions):
all_step_results = self._core_iterator(
general_suffix,
sim_state=act_on_args.copy()
if i < repetitions - 1 else act_on_args,
)
for step_result in all_step_results:
pass
for k, v in step_result.measurements.items():
if k not in measurements:
measurements[k] = []
measurements[k].append(np.array(v, dtype=np.uint8))
return {k: np.array(v) for k, v in measurements.items()}
def _run(
self,
circuit: 'cirq.AbstractCircuit',
param_resolver: 'cirq.ParamResolver',
repetitions: int,
) -> Dict[str, np.ndarray]:
"""See definition in `cirq.SimulatesSamples`."""
param_resolver = param_resolver or study.ParamResolver({})
resolved_circuit = protocols.resolve_parameters(circuit, param_resolver)
check_all_resolved(resolved_circuit)
qubits = tuple(sorted(resolved_circuit.all_qubits()))
sim_state = self._create_simulation_state(0, qubits)
prefix, general_suffix = (
split_into_matching_protocol_then_general(resolved_circuit, self._can_be_in_run_prefix)
if self._can_be_in_run_prefix(self.noise)
else (resolved_circuit[0:0], resolved_circuit)
)
step_result = None
for step_result in self._core_iterator(circuit=prefix, sim_state=sim_state):
pass
general_ops = list(general_suffix.all_operations())
if all(isinstance(op.gate, ops.MeasurementGate) for op in general_ops):
for step_result in self._core_iterator(
circuit=general_suffix, sim_state=sim_state, all_measurements_are_terminal=True
):
pass
assert step_result is not None
measurement_ops = [cast(ops.GateOperation, op) for op in general_ops]
return step_result.sample_measurement_ops(
measurement_ops, repetitions, seed=self._prng, _allow_repeated=True
)
records: Dict['cirq.MeasurementKey', List[Sequence[Sequence[int]]]] = {}
for i in range(repetitions):
for step_result in self._core_iterator(
general_suffix,
sim_state=sim_state.copy(deep_copy_buffers=False)
if i < repetitions - 1
else sim_state,
):
pass
for k, r in step_result._classical_data.records.items():
if k not in records:
records[k] = []
records[k].append(r)
for k, cr in step_result._classical_data.channel_records.items():
if k not in records:
records[k] = []
records[k].append([cr])
def pad_evenly(results: Sequence[Sequence[Sequence[int]]]):
largest = max(len(result) for result in results)
xs = np.zeros((len(results), largest, len(results[0][0])), dtype=np.uint8)
for i, result in enumerate(results):
xs[i, 0 : len(result), :] = result
return xs
return {str(k): pad_evenly(v) for k, v in records.items()}
def _run(self, circuit: circuits.Circuit,
param_resolver: study.ParamResolver,
repetitions: int) -> Dict[str, np.ndarray]:
"""See definition in `cirq.SimulatesSamples`."""
param_resolver = param_resolver or study.ParamResolver({})
resolved_circuit = protocols.resolve_parameters(
circuit, param_resolver)
check_all_resolved(resolved_circuit)
if circuit.are_all_measurements_terminal():
return self._run_sweep_sample(resolved_circuit, repetitions)
return self._run_sweep_repeat(resolved_circuit, repetitions)
def _run(self, circuit: circuits.Circuit,
param_resolver: study.ParamResolver,
repetitions: int) -> Dict[str, np.ndarray]:
"""See definition in `cirq.SimulatesSamples`."""
param_resolver = param_resolver or study.ParamResolver({})
resolved_circuit = protocols.resolve_parameters(
circuit, param_resolver)
check_all_resolved(resolved_circuit)
_, general_suffix = split_into_matching_protocol_then_general(
resolved_circuit, lambda op: not protocols.is_measurement(op))
if general_suffix.are_all_measurements_terminal() and not any(
general_suffix.findall_operations(
lambda op: isinstance(op, circuits.CircuitOperation))):
return self._run_sweep_sample(resolved_circuit, repetitions)
return self._run_sweep_repeat(resolved_circuit, repetitions)
def _run(self, circuit: circuits.Circuit,
param_resolver: study.ParamResolver,
repetitions: int) -> Dict[str, np.ndarray]:
"""See definition in `cirq.SimulatesSamples`."""
param_resolver = param_resolver or study.ParamResolver({})
resolved_circuit = protocols.resolve_parameters(
circuit, param_resolver)
check_all_resolved(resolved_circuit)
qubit_order = sorted(resolved_circuit.all_qubits())
# Simulate as many unitary operations as possible before having to
# repeat work for each sample.
unitary_prefix, general_suffix = (
split_into_matching_protocol_then_general(resolved_circuit,
protocols.has_unitary)
if protocols.has_unitary(self.noise) else
(resolved_circuit[0:0], resolved_circuit))
step_result = None
for step_result in self._base_iterator(
circuit=unitary_prefix,
qubit_order=qubit_order,
initial_state=0,
perform_measurements=False,
):
pass
assert step_result is not None
# When an otherwise unitary circuit ends with non-demolition computation
# basis measurements, we can sample the results more efficiently.
general_ops = list(general_suffix.all_operations())
if all(isinstance(op.gate, ops.MeasurementGate) for op in general_ops):
return step_result.sample_measurement_ops(
measurement_ops=cast(List[ops.GateOperation], general_ops),
repetitions=repetitions,
seed=self._prng,
)
qid_shape = protocols.qid_shape(qubit_order)
intermediate_state = step_result.state_vector().reshape(qid_shape)
return self._brute_force_samples(
initial_state=intermediate_state,
circuit=general_suffix,
repetitions=repetitions,
qubit_order=qubit_order,
)
def _run(self, circuit: circuits.Circuit,
param_resolver: study.ParamResolver,
repetitions: int) -> Dict[str, np.ndarray]:
"""Run a simulation, mimicking quantum hardware."""
param_resolver = param_resolver or study.ParamResolver({})
resolved_circuit = protocols.resolve_parameters(
circuit, param_resolver)
check_all_resolved(resolved_circuit)
qubit_order = sorted(resolved_circuit.all_qubits())
self._number_of_qubits = len(qubit_order)
# Simulate as many unitary operations as possible before having to
# repeat work for each sample.
unitary_prefix, general_suffix = (
split_into_matching_protocol_then_general(resolved_circuit,
protocols.has_unitary))
qubits = ops.QubitOrder.as_qubit_order(qubit_order).order_for(
unitary_prefix.all_qubits())
num_qubits = len(qubits)
qid_shape = protocols.qid_shape(qubits)
qubit_map = {q: i for i, q in enumerate(qubits)}
self._sample_measure = True
self._sim = qrack_controller_factory()
self._sim.initialize_qreg(self._configuration['opencl'],
self._configuration['schmidt_decompose'],
self._configuration['paging'],
self._configuration['stabilizer'],
self._number_of_qubits,
self._configuration['opencl_device_id'],
self._configuration['opencl_multi'],
self._configuration['normalize'],
self._configuration['zero_threshold'])
for moment in unitary_prefix:
operations = moment.operations
for op in operations:
indices = [
num_qubits - 1 - qubit_map[qubit] for qubit in op.qubits
]
self._try_gate(op, indices)
general_ops = list(general_suffix.all_operations())
if all(isinstance(op.gate, ops.MeasurementGate) for op in general_ops):
indices = []
for op in general_ops:
indices = indices + [
num_qubits - 1 - qubit_map[qubit] for qubit in op.qubits
]
sample_measure = self._add_sample_measure(indices, repetitions)
for sample in sample_measure:
qb_index = 0
for op in general_ops:
key = protocols.measurement_key(op.gate)
value = []
for _ in op.qubits:
value.append(sample[qb_index])
qb_index = qb_index + 1
self._memory[key].append(value)
return self._memory
self._sample_measure = False
preamble_sim = self._sim
for shot in range(repetitions):
self._sim = preamble_sim.clone()
for moment in general_suffix:
operations = moment.operations
for op in operations:
indices = [
num_qubits - 1 - qubit_map[qubit]
for qubit in op.qubits
]
key = protocols.measurement_key(op.gate)
self._memory[key].append(self._add_qasm_measure(indices))
return self._memory
def _run(
self,
circuit: 'cirq.AbstractCircuit',
param_resolver: 'cirq.ParamResolver',
repetitions: int,
) -> Dict[str, np.ndarray]:
"""See definition in `cirq.SimulatesSamples`."""
if self._ignore_measurement_results:
raise ValueError(
"run() is not supported when ignore_measurement_results = True"
)
param_resolver = param_resolver or study.ParamResolver({})
resolved_circuit = protocols.resolve_parameters(
circuit, param_resolver)
check_all_resolved(resolved_circuit)
qubits = tuple(sorted(resolved_circuit.all_qubits()))
act_on_args = self._create_act_on_args(0, qubits)
prefix, general_suffix = (split_into_matching_protocol_then_general(
resolved_circuit, self._can_be_in_run_prefix) if
self._can_be_in_run_prefix(self.noise) else
(resolved_circuit[0:0], resolved_circuit))
step_result = None
for step_result in self._core_iterator(
circuit=prefix,
sim_state=act_on_args,
):
pass
general_ops = list(general_suffix.all_operations())
if all(isinstance(op.gate, ops.MeasurementGate) for op in general_ops):
for step_result in self._core_iterator(
circuit=general_suffix,
sim_state=act_on_args,
all_measurements_are_terminal=True,
):
pass
assert step_result is not None
measurement_ops = [
cast(ops.GateOperation, op) for op in general_ops
]
return step_result.sample_measurement_ops(measurement_ops,
repetitions,
seed=self._prng,
_allow_repeated=True)
records: Dict['cirq.MeasurementKey', List[np.ndarray]] = {}
for i in range(repetitions):
if 'deep_copy_buffers' in inspect.signature(
act_on_args.copy).parameters:
all_step_results = self._core_iterator(
general_suffix,
sim_state=act_on_args.copy(deep_copy_buffers=False)
if i < repetitions - 1 else act_on_args,
)
else:
warnings.warn(
('A new parameter deep_copy_buffers has been added to ActOnArgs.copy(). The '
'classes that inherit from ActOnArgs should support it before Cirq 0.15.'
),
DeprecationWarning,
)
all_step_results = self._core_iterator(
general_suffix,
sim_state=act_on_args.copy()
if i < repetitions - 1 else act_on_args,
)
for step_result in all_step_results:
pass
for k, r in step_result._classical_data.records.items():
if k not in records:
records[k] = []
records[k].append(r)
for k, cr in step_result._classical_data.channel_records.items():
if k not in records:
records[k] = []
records[k].append([cr])
return {
str(k): np.array(v, dtype=np.uint8)
for k, v in records.items()
}
