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() }